Launcher, app/base, sentry, update service

internal/api/api.go

@@ -22,14 +22,12 @@
 package api
 
 import (
-	"crypto/tls"
 	"fmt"
 	"net/http"
 
 	"github.com/ProtonMail/proton-bridge/internal/bridge"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
 	"github.com/ProtonMail/proton-bridge/internal/events"
-	"github.com/ProtonMail/proton-bridge/internal/preferences"
-	"github.com/ProtonMail/proton-bridge/pkg/config"
 	"github.com/ProtonMail/proton-bridge/pkg/listener"
 	"github.com/ProtonMail/proton-bridge/pkg/ports"
 	"github.com/sirupsen/logrus"
@@ -41,21 +39,15 @@ var (
 
 type apiServer struct {
 	host          string
-	pref          *config.Preferences
-	tls           *tls.Config
-	certPath      string
-	keyPath       string
+	settings      *settings.Settings
 	eventListener listener.Listener
 }
 
 // NewAPIServer returns prepared API server struct.
-func NewAPIServer(pref *config.Preferences, tls *tls.Config, certPath, keyPath string, eventListener listener.Listener) *apiServer { //nolint[golint]
+func NewAPIServer(settings *settings.Settings, eventListener listener.Listener) *apiServer { //nolint[golint]
 	return &apiServer{
 		host:          bridge.Host,
-		pref:          pref,
-		tls:           tls,
-		certPath:      certPath,
-		keyPath:       keyPath,
+		settings:      settings,
 		eventListener: eventListener,
 	}
 }
@@ -67,14 +59,12 @@ func (api *apiServer) ListenAndServe() {
 
 	addr := api.getAddress()
 	server := &http.Server{
-		Addr:         addr,
-		Handler:      mux,
-		TLSConfig:    api.tls,
-		TLSNextProto: make(map[string]func(*http.Server, *tls.Conn, http.Handler)),
+		Addr:    addr,
+		Handler: mux,
 	}
 
 	log.Info("API listening at ", addr)
-	if err := server.ListenAndServeTLS(api.certPath, api.keyPath); err != nil {
+	if err := server.ListenAndServe(); err != nil {
 		api.eventListener.Emit(events.ErrorEvent, "API failed: "+err.Error())
 		log.Error("API failed: ", err)
 	}
@@ -82,10 +72,10 @@ func (api *apiServer) ListenAndServe() {
 }
 
 func (api *apiServer) getAddress() string {
-	port := api.pref.GetInt(preferences.APIPortKey)
+	port := api.settings.GetInt(settings.APIPortKey)
 	newPort := ports.FindFreePortFrom(port)
 	if newPort != port {
-		api.pref.SetInt(preferences.APIPortKey, newPort)
+		api.settings.SetInt(settings.APIPortKey, newPort)
 	}
 	return getAPIAddress(api.host, newPort)
 }

internal/api/focus.go

@@ -18,7 +18,6 @@
 package api
 
 import (
-	"crypto/tls"
 	"fmt"
 	"net/http"
 
@@ -37,12 +36,9 @@ func focusHandler(ctx handlerContext) error {
 
 // CheckOtherInstanceAndFocus is helper for new instances to check if there is
 // already a running instance and get it's focus.
-func CheckOtherInstanceAndFocus(port int, tls *tls.Config) error {
-	transport := &http.Transport{TLSClientConfig: tls}
-	client := &http.Client{Transport: transport}
-
+func CheckOtherInstanceAndFocus(port int) error {
 	addr := getAPIAddress(bridge.Host, port)
-	resp, err := client.Get("https://" + addr + "/focus")
+	resp, err := (&http.Client{}).Get("http://" + addr + "/focus")
 	if err != nil {
 		return err
 	}

internal/app/base/args.go

@@ -15,21 +15,21 @@
 // You should have received a copy of the GNU General Public License
 // along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
 
-package cmd
+package base
 
-import (
-	"os"
-	"strings"
-)
+import "strings"
 
-// filterProcessSerialNumberFromArgs removes additional flag from MacOS. More info ProcessSerialNumber
+// StripProcessSerialNumber removes additional flag from macOS.
+// More info:
 // http://mirror.informatimago.com/next/developer.apple.com/documentation/Carbon/Reference/Process_Manager/prmref_main/data_type_5.html#//apple_ref/doc/uid/TP30000208/C001951
-func filterProcessSerialNumberFromArgs() {
-	tmp := os.Args[:0]
-	for _, arg := range os.Args {
+func StripProcessSerialNumber(args []string) []string {
+	res := args[:0]
+
+	for _, arg := range args {
 		if !strings.Contains(arg, "-psn_") {
-			tmp = append(tmp, arg)
+			res = append(res, arg)
 		}
 	}
-	os.Args = tmp
+
+	return res
 }

internal/app/base/base.go

@@ -0,0 +1,307 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+// Package base implements a common application base currently shared by bridge and IE.
+// The base includes the following:
+//  - access to standard filesystem locations like config, cache, logging dirs
+//  - an extensible crash handler
+//  - versioned cache directory
+//  - persistent settings
+//  - event listener
+//  - credentials store
+//  - pmapi ClientManager
+// In addition, the base initialises logging and reacts to command line arguments
+// which control the log verbosity and enable cpu/memory profiling.
+package base
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"runtime/pprof"
+
+	"github.com/Masterminds/semver/v3"
+	"github.com/ProtonMail/go-appdir"
+	"github.com/ProtonMail/gopenpgp/v2/crypto"
+	"github.com/ProtonMail/proton-bridge/internal/api"
+	"github.com/ProtonMail/proton-bridge/internal/config/cache"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
+	"github.com/ProtonMail/proton-bridge/internal/config/tls"
+	"github.com/ProtonMail/proton-bridge/internal/constants"
+	"github.com/ProtonMail/proton-bridge/internal/cookies"
+	"github.com/ProtonMail/proton-bridge/internal/crash"
+	"github.com/ProtonMail/proton-bridge/internal/events"
+	"github.com/ProtonMail/proton-bridge/internal/locations"
+	"github.com/ProtonMail/proton-bridge/internal/logging"
+	"github.com/ProtonMail/proton-bridge/internal/updater"
+	"github.com/ProtonMail/proton-bridge/internal/users/credentials"
+	"github.com/ProtonMail/proton-bridge/internal/versioner"
+	"github.com/ProtonMail/proton-bridge/pkg/listener"
+	"github.com/ProtonMail/proton-bridge/pkg/pmapi"
+	"github.com/ProtonMail/proton-bridge/pkg/sentry"
+	"github.com/allan-simon/go-singleinstance"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v2"
+)
+
+type Base struct {
+	CrashHandler *crash.Handler
+	Locations    *locations.Locations
+	Settings     *settings.Settings
+	Lock         *os.File
+	Cache        *cache.Cache
+	Listener     listener.Listener
+	Creds        *credentials.Store
+	CM           *pmapi.ClientManager
+	Updater      *updater.Updater
+	Versioner    *versioner.Versioner
+	TLS          *tls.TLS
+
+	name  string
+	usage string
+
+	restart bool
+}
+
+func New( // nolint[funlen]
+	appName,
+	appUsage,
+	configName,
+	updateURLName,
+	keychainName,
+	cacheVersion string,
+) (*Base, error) {
+	sentryReporter := sentry.NewReporter(appName, constants.Version)
+
+	crashHandler := crash.NewHandler(
+		sentryReporter.Report,
+		crash.ShowErrorNotification(appName),
+	)
+	defer crashHandler.HandlePanic()
+
+	locations := locations.New(
+		appdir.New(filepath.Join(constants.VendorName, configName)),
+		configName,
+	)
+	if err := locations.Clean(); err != nil {
+		return nil, err
+	}
+
+	logsPath, err := locations.ProvideLogsPath()
+	if err != nil {
+		return nil, err
+	}
+	if err := logging.Init(logsPath); err != nil {
+		return nil, err
+	}
+	crashHandler.AddRecoveryAction(logging.DumpStackTrace(logsPath))
+
+	settingsPath, err := locations.ProvideSettingsPath()
+	if err != nil {
+		return nil, err
+	}
+	settingsObj := settings.New(settingsPath)
+
+	lock, err := singleinstance.CreateLockFile(locations.GetLockFile())
+	if err != nil {
+		logrus.Warnf("%v is already running", appName)
+		return nil, api.CheckOtherInstanceAndFocus(settingsObj.GetInt(settings.APIPortKey))
+	}
+
+	cachePath, err := locations.ProvideCachePath()
+	if err != nil {
+		return nil, err
+	}
+	cache, err := cache.New(cachePath, cacheVersion)
+	if err != nil {
+		return nil, err
+	}
+	if err := cache.RemoveOldVersions(); err != nil {
+		return nil, err
+	}
+
+	listener := listener.New()
+	events.SetupEvents(listener)
+
+	// NOTE: If we can't load the credentials for whatever reason,
+	// do we really want to error out? Need to signal to frontend.
+	creds, err := credentials.NewStore(keychainName)
+	if err != nil {
+		logrus.WithError(err).Error("Could not get credentials store")
+		listener.Emit(events.CredentialsErrorEvent, err.Error())
+	}
+
+	jar, err := cookies.NewCookieJar(settingsObj)
+	if err != nil {
+		return nil, err
+	}
+
+	cm := pmapi.NewClientManager(pmapi.GetAPIConfig(configName, constants.Version))
+	cm.SetRoundTripper(pmapi.GetRoundTripper(cm, listener))
+	cm.SetCookieJar(jar)
+
+	sentryReporter.SetUserAgentProvider(cm)
+
+	tls := tls.New(settingsPath)
+
+	key, err := crypto.NewKeyFromArmored(updater.DefaultPublicKey)
+	if err != nil {
+		return nil, err
+	}
+
+	kr, err := crypto.NewKeyRing(key)
+	if err != nil {
+		return nil, err
+	}
+
+	updatesDir, err := locations.ProvideUpdatesPath()
+	if err != nil {
+		return nil, err
+	}
+
+	versioner := versioner.New(updatesDir)
+
+	installer := updater.NewInstaller(versioner)
+
+	updater := updater.New(
+		cm,
+		installer,
+		kr,
+		semver.MustParse(constants.Version),
+		updateURLName,
+		runtime.GOOS,
+		settingsObj.GetFloat64(settings.RolloutKey),
+	)
+
+	return &Base{
+		CrashHandler: crashHandler,
+		Locations:    locations,
+		Settings:     settingsObj,
+		Lock:         lock,
+		Cache:        cache,
+		Listener:     listener,
+		Creds:        creds,
+		CM:           cm,
+		Updater:      updater,
+		Versioner:    versioner,
+		TLS:          tls,
+
+		name:  appName,
+		usage: appUsage,
+	}, nil
+}
+
+func (b *Base) NewApp(action func(*Base, *cli.Context) error) *cli.App {
+	app := cli.NewApp()
+
+	app.Name = b.name
+	app.Usage = b.usage
+	app.Version = constants.Version
+	app.Action = b.run(action)
+	app.Flags = []cli.Flag{
+		&cli.BoolFlag{
+			Name:    "cpu-prof",
+			Aliases: []string{"p"},
+			Usage:   "Generate CPU profile",
+		},
+		&cli.BoolFlag{
+			Name:    "mem-prof",
+			Aliases: []string{"m"},
+			Usage:   "Generate memory profile",
+		},
+		&cli.StringFlag{
+			Name:    "log-level",
+			Aliases: []string{"l"},
+			Usage:   "Set the log level (one of panic, fatal, error, warn, info, debug)",
+		},
+		&cli.BoolFlag{
+			Name:    "cli",
+			Aliases: []string{"c"},
+			Usage:   "Use command line interface",
+		},
+		&cli.StringFlag{
+			Name:   "restart",
+			Usage:  "The number of times the application has already restarted",
+			Hidden: true,
+		},
+		&cli.StringFlag{
+			Name:   "launcher",
+			Usage:  "The launcher to use to restart the application",
+			Hidden: true,
+		},
+	}
+
+	return app
+}
+
+// SetToRestart sets the app to restart the next time it is closed.
+func (b *Base) SetToRestart() {
+	b.restart = true
+}
+
+func (b *Base) run(appMainLoop func(*Base, *cli.Context) error) cli.ActionFunc { // nolint[funlen]
+	return func(c *cli.Context) error {
+		defer b.CrashHandler.HandlePanic()
+		defer func() { _ = b.Lock.Close() }()
+
+		if doCPUProfile := c.Bool("cpu-prof"); doCPUProfile {
+			startCPUProfile()
+			defer pprof.StopCPUProfile()
+		}
+
+		if doMemoryProfile := c.Bool("mem-prof"); doMemoryProfile {
+			defer makeMemoryProfile()
+		}
+
+		logging.SetLevel(c.String("log-level"))
+
+		logrus.
+			WithField("appName", b.name).
+			WithField("version", constants.Version).
+			WithField("revision", constants.Revision).
+			WithField("build", constants.BuildTime).
+			WithField("runtime", runtime.GOOS).
+			WithField("args", os.Args).
+			Info("Run app")
+
+		b.CrashHandler.AddRecoveryAction(func(interface{}) error {
+			if c.Int("restart") > maxAllowedRestarts {
+				logrus.
+					WithField("restart", c.Int("restart")).
+					Warn("Not restarting, already restarted too many times")
+
+				return nil
+			}
+
+			return restartApp(c.String("launcher"), true)
+		})
+
+		if err := appMainLoop(b, c); err != nil {
+			return err
+		}
+
+		if b.restart {
+			return restartApp(c.String("launcher"), false)
+		}
+
+		if err := b.Versioner.RemoveOldVersions(); err != nil {
+			return err
+		}
+
+		return nil
+	}
+}

internal/app/base/migration.go

@@ -0,0 +1,81 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package base
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/ProtonMail/go-appdir"
+	"github.com/ProtonMail/proton-bridge/internal/constants"
+	"github.com/ProtonMail/proton-bridge/internal/locations"
+	"github.com/sirupsen/logrus"
+)
+
+// MigrateFiles migrates files from their old (pre-refactor) locations to their new locations.
+// We can remove this eventually.
+//
+// | entity |               old location                |            new location                |
+// |--------|-------------------------------------------|----------------------------------------|
+// | prefs  | ~/.cache/protonmail/<app>/c11/prefs.json  | ~/.config/protonmail/<app>/prefs.json  |
+// | c11    | ~/.cache/protonmail/<app>/c11             | ~/.cache/protonmail/<app>/cache/c11    |
+func MigrateFiles(configName string) error {
+	appDirs := appdir.New(filepath.Join(constants.VendorName, configName))
+	locations := locations.New(appDirs, configName)
+
+	userCacheDir := appDirs.UserCache()
+	newSettingsDir, err := locations.ProvideSettingsPath()
+	if err != nil {
+		return err
+	}
+
+	if err := moveIfExists(
+		filepath.Join(userCacheDir, "c11", "prefs.json"),
+		filepath.Join(newSettingsDir, "prefs.json"),
+	); err != nil {
+		return err
+	}
+
+	newCacheDir, err := locations.ProvideCachePath()
+	if err != nil {
+		return err
+	}
+
+	if err := moveIfExists(
+		filepath.Join(userCacheDir, "c11"),
+		filepath.Join(newCacheDir, "c11"),
+	); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func moveIfExists(source, destination string) error {
+	if _, err := os.Stat(source); os.IsNotExist(err) {
+		logrus.WithField("source", source).WithField("destination", destination).Debug("No need to migrate file")
+		return nil
+	}
+
+	if _, err := os.Stat(destination); !os.IsNotExist(err) {
+		logrus.WithField("source", source).WithField("destination", destination).Debug("No need to migrate file")
+		return nil
+	}
+
+	return os.Rename(source, destination)
+}

internal/app/base/profiling.go

@@ -15,40 +15,42 @@
 // You should have received a copy of the GNU General Public License
 // along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
 
-package cmd
+package base
 
 import (
 	"os"
 	"path/filepath"
 	"runtime"
 	"runtime/pprof"
+
+	"github.com/sirupsen/logrus"
 )
 
-// StartCPUProfile starts CPU pprof.
-func StartCPUProfile() {
+// startCPUProfile starts CPU pprof.
+func startCPUProfile() {
 	f, err := os.Create("./cpu.pprof")
 	if err != nil {
-		log.Fatal("Could not create CPU profile: ", err)
+		logrus.Fatal("Could not create CPU profile: ", err)
 	}
 	if err := pprof.StartCPUProfile(f); err != nil {
-		log.Fatal("Could not start CPU profile: ", err)
+		logrus.Fatal("Could not start CPU profile: ", err)
 	}
 }
 
-// MakeMemoryProfile generates memory pprof.
-func MakeMemoryProfile() {
+// makeMemoryProfile generates memory pprof.
+func makeMemoryProfile() {
 	name := "./mem.pprof"
 	f, err := os.Create(name)
 	if err != nil {
-		log.Fatal("Could not create memory profile: ", err)
+		logrus.Fatal("Could not create memory profile: ", err)
 	}
 	if abs, err := filepath.Abs(name); err == nil {
 		name = abs
 	}
-	log.Info("Writing memory profile to ", name)
+	logrus.Info("Writing memory profile to ", name)
 	runtime.GC() // get up-to-date statistics
 	if err := pprof.WriteHeapProfile(f); err != nil {
-		log.Fatal("Could not write memory profile: ", err)
+		logrus.Fatal("Could not write memory profile: ", err)
 	}
 	_ = f.Close()
 }

internal/app/base/restart.go

@@ -0,0 +1,88 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package base
+
+import (
+	"os"
+	"os/exec"
+	"strconv"
+
+	"github.com/sirupsen/logrus"
+)
+
+// maxAllowedRestarts controls after how many crashes the app will give up restarting.
+const maxAllowedRestarts = 10
+
+func restartApp(path string, crash bool) error {
+	if path == "" {
+		exe, err := os.Executable()
+		if err != nil {
+			return err
+		}
+
+		path = exe
+	}
+
+	var args []string
+
+	if crash {
+		args = incrementRestartFlag(os.Args)[1:]
+	} else {
+		args = os.Args[1:]
+	}
+
+	logrus.
+		WithField("path", path).
+		WithField("args", args).
+		Warn("Restarting")
+
+	return exec.Command(path, args...).Start() // nolint[gosec]
+}
+
+// incrementRestartFlag increments the value of the restart flag.
+// If no such flag is present, it is added with initial value 1.
+func incrementRestartFlag(args []string) []string {
+	res := append([]string{}, args...)
+
+	hasFlag := false
+
+	for k, v := range res {
+		if v != "--restart" {
+			continue
+		}
+
+		hasFlag = true
+
+		if k+1 >= len(res) {
+			continue
+		}
+
+		n, err := strconv.Atoi(res[k+1])
+		if err != nil {
+			res[k+1] = "1"
+		} else {
+			res[k+1] = strconv.Itoa(n + 1)
+		}
+	}
+
+	if !hasFlag {
+		res = append(res, "--restart", "1")
+	}
+
+	return res
+}

internal/app/base/restart_test.go

@@ -0,0 +1,49 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package base
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIncrementRestartFlag(t *testing.T) {
+	var tests = []struct {
+		in  []string
+		out []string
+	}{
+		{[]string{"./bridge", "--restart", "1"}, []string{"./bridge", "--restart", "2"}},
+		{[]string{"./bridge", "--restart", "2"}, []string{"./bridge", "--restart", "3"}},
+		{[]string{"./bridge", "--other", "--restart", "2"}, []string{"./bridge", "--other", "--restart", "3"}},
+		{[]string{"./bridge", "--restart", "2", "--other"}, []string{"./bridge", "--restart", "3", "--other"}},
+		{[]string{"./bridge", "--restart", "2", "--other", "2"}, []string{"./bridge", "--restart", "3", "--other", "2"}},
+		{[]string{"./bridge"}, []string{"./bridge", "--restart", "1"}},
+		{[]string{"./bridge", "--something"}, []string{"./bridge", "--something", "--restart", "1"}},
+		{[]string{"./bridge", "--something", "--else"}, []string{"./bridge", "--something", "--else", "--restart", "1"}},
+		{[]string{"./bridge", "--restart", "bad"}, []string{"./bridge", "--restart", "1"}},
+		{[]string{"./bridge", "--restart", "bad", "--other"}, []string{"./bridge", "--restart", "1", "--other"}},
+	}
+
+	for _, tt := range tests {
+		t.Run(strings.Join(tt.in, " "), func(t *testing.T) {
+			assert.Equal(t, tt.out, incrementRestartFlag(tt.in))
+		})
+	}
+}

internal/app/bridge/bridge.go

@@ -0,0 +1,137 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+// Package bridge implements the bridge CLI application.
+package bridge
+
+import (
+	"time"
+
+	"github.com/ProtonMail/proton-bridge/internal/api"
+	"github.com/ProtonMail/proton-bridge/internal/app/base"
+	"github.com/ProtonMail/proton-bridge/internal/bridge"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
+	"github.com/ProtonMail/proton-bridge/internal/constants"
+	"github.com/ProtonMail/proton-bridge/internal/frontend"
+	"github.com/ProtonMail/proton-bridge/internal/imap"
+	"github.com/ProtonMail/proton-bridge/internal/smtp"
+	"github.com/ProtonMail/proton-bridge/internal/updater"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v2"
+)
+
+func New(base *base.Base) *cli.App {
+	app := base.NewApp(run)
+
+	app.Flags = append(app.Flags, []cli.Flag{
+		&cli.StringFlag{
+			Name:  "log-imap",
+			Usage: "Enable logging of IMAP communications (all|client|server) (may contain decrypted data!)"},
+		&cli.BoolFlag{
+			Name:  "log-smtp",
+			Usage: "Enable logging of SMTP communications (may contain decrypted data!)"},
+		&cli.BoolFlag{
+			Name:  "no-window",
+			Usage: "Don't show window after start"},
+		&cli.BoolFlag{
+			Name:  "noninteractive",
+			Usage: "Start Bridge entirely noninteractively"},
+	}...)
+
+	return app
+}
+
+func run(b *base.Base, c *cli.Context) error { // nolint[funlen]
+	tls, err := b.TLS.GetConfig()
+	if err != nil {
+		logrus.WithError(err).Fatal("Failed to create TLS config")
+	}
+
+	bridge := bridge.New(b.Locations, b.Cache, b.Settings, b.CrashHandler, b.Listener, b.CM, b.Creds)
+	imapBackend := imap.NewIMAPBackend(b.CrashHandler, b.Listener, b.Cache, bridge)
+	smtpBackend := smtp.NewSMTPBackend(b.CrashHandler, b.Listener, b.Settings, bridge)
+
+	go func() {
+		defer b.CrashHandler.HandlePanic()
+		api.NewAPIServer(b.Settings, b.Listener).ListenAndServe()
+	}()
+
+	go func() {
+		defer b.CrashHandler.HandlePanic()
+		imapPort := b.Settings.GetInt(settings.IMAPPortKey)
+		imap.NewIMAPServer(
+			c.String("log-imap") == "client" || c.String("log-imap") == "all",
+			c.String("log-imap") == "server" || c.String("log-imap") == "all",
+			imapPort, tls, imapBackend, b.Listener).ListenAndServe()
+	}()
+
+	go func() {
+		defer b.CrashHandler.HandlePanic()
+		smtpPort := b.Settings.GetInt(settings.SMTPPortKey)
+		useSSL := b.Settings.GetBool(settings.SMTPSSLKey)
+		smtp.NewSMTPServer(
+			c.Bool("log-smtp"),
+			smtpPort, useSSL, tls, smtpBackend, b.Listener).ListenAndServe()
+	}()
+
+	var frontendMode string
+
+	switch {
+	case c.Bool("cli"):
+		frontendMode = "cli"
+	case c.Bool("noninteractive"):
+		frontendMode = "noninteractive"
+	default:
+		frontendMode = "qt"
+	}
+
+	if frontendMode == "noninteractive" {
+		<-(make(chan struct{}))
+		return nil
+	}
+
+	f := frontend.New(
+		constants.Version,
+		constants.BuildVersion,
+		frontendMode,
+		!c.Bool("no-window"),
+		b.CrashHandler,
+		b.Locations,
+		b.Settings,
+		b.Listener,
+		b.Updater,
+		bridge,
+		smtpBackend,
+		b,
+	)
+
+	b.Updater.Watch(
+		time.Hour,
+		func(update updater.VersionInfo) error {
+			if !b.Settings.GetBool(settings.AutoUpdateKey) {
+				return f.NotifyManualUpdate(update)
+			}
+
+			return b.Updater.InstallUpdate(update)
+		},
+		func(err error) {
+			logrus.WithError(err).Error("An error occurred while watching for updates")
+		},
+	)
+
+	return f.Loop()
+}

internal/app/ie/ie.go

@@ -0,0 +1,83 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+// Package ie implements the ie CLI application.
+package ie
+
+import (
+	"time"
+
+	"github.com/ProtonMail/proton-bridge/internal/api"
+	"github.com/ProtonMail/proton-bridge/internal/app/base"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
+	"github.com/ProtonMail/proton-bridge/internal/constants"
+	"github.com/ProtonMail/proton-bridge/internal/frontend"
+	"github.com/ProtonMail/proton-bridge/internal/importexport"
+	"github.com/ProtonMail/proton-bridge/internal/updater"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v2"
+)
+
+func New(b *base.Base) *cli.App {
+	return b.NewApp(run)
+}
+
+func run(b *base.Base, c *cli.Context) error {
+	ie := importexport.New(b.Locations, b.Cache, b.CrashHandler, b.Listener, b.CM, b.Creds)
+
+	go func() {
+		defer b.CrashHandler.HandlePanic()
+		api.NewAPIServer(b.Settings, b.Listener).ListenAndServe()
+	}()
+
+	var frontendMode string
+
+	switch {
+	case c.Bool("cli"):
+		frontendMode = "cli"
+	default:
+		frontendMode = "qt"
+	}
+
+	f := frontend.NewImportExport(
+		constants.Version,
+		constants.BuildVersion,
+		frontendMode,
+		b.CrashHandler,
+		b.Locations,
+		b.Listener,
+		b.Updater,
+		ie,
+		b,
+	)
+
+	b.Updater.Watch(
+		time.Hour,
+		func(update updater.VersionInfo) error {
+			if !b.Settings.GetBool(settings.AutoUpdateKey) {
+				return f.NotifyManualUpdate(update)
+			}
+
+			return b.Updater.InstallUpdate(update)
+		},
+		func(err error) {
+			logrus.WithError(err).Error("An error occurred while watching for updates")
+		},
+	)
+
+	return f.Loop()
+}

internal/bridge/bridge.go

@@ -22,8 +22,9 @@ import (
 	"strconv"
 	"time"
 
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
+	"github.com/ProtonMail/proton-bridge/internal/constants"
 	"github.com/ProtonMail/proton-bridge/internal/metrics"
-	"github.com/ProtonMail/proton-bridge/internal/preferences"
 	"github.com/ProtonMail/proton-bridge/internal/users"
 	"github.com/ProtonMail/proton-bridge/pkg/pmapi"
 
@@ -38,7 +39,7 @@ var (
 type Bridge struct {
 	*users.Users
 
-	pref          PreferenceProvider
+	settings      SettingsProvider
 	clientManager users.ClientManager
 
 	userAgentClientName    string
@@ -47,8 +48,9 @@ type Bridge struct {
 }
 
 func New(
-	config Configer,
-	pref PreferenceProvider,
+	locations Locator,
+	cache Cacher,
+	s SettingsProvider,
 	panicHandler users.PanicHandler,
 	eventListener listener.Listener,
 	clientManager users.ClientManager,
@@ -56,22 +58,22 @@ func New(
 ) *Bridge {
 	// Allow DoH before starting the app if the user has previously set this setting.
 	// This allows us to start even if protonmail is blocked.
-	if pref.GetBool(preferences.AllowProxyKey) {
+	if s.GetBool(settings.AllowProxyKey) {
 		clientManager.AllowProxy()
 	}
 
-	storeFactory := newStoreFactory(config, panicHandler, clientManager, eventListener)
-	u := users.New(config, panicHandler, eventListener, clientManager, credStorer, storeFactory, true)
+	storeFactory := newStoreFactory(cache, panicHandler, clientManager, eventListener)
+	u := users.New(locations, panicHandler, eventListener, clientManager, credStorer, storeFactory, true)
 	b := &Bridge{
 		Users: u,
 
-		pref:          pref,
+		settings:      s,
 		clientManager: clientManager,
 	}
 
-	if pref.GetBool(preferences.FirstStartKey) {
-		b.SendMetric(metrics.New(metrics.Setup, metrics.FirstStart, metrics.Label(config.GetVersion())))
-		pref.SetBool(preferences.FirstStartKey, false)
+	if s.GetBool(settings.FirstStartKey) {
+		b.SendMetric(metrics.New(metrics.Setup, metrics.FirstStart, metrics.Label(constants.Version)))
+		s.SetBool(settings.FirstStartKey, false)
 	}
 
 	go b.heartbeat()
@@ -84,7 +86,7 @@ func (b *Bridge) heartbeat() {
 	ticker := time.NewTicker(1 * time.Minute)
 
 	for range ticker.C {
-		next, err := strconv.ParseInt(b.pref.Get(preferences.NextHeartbeatKey), 10, 64)
+		next, err := strconv.ParseInt(b.settings.Get(settings.NextHeartbeatKey), 10, 64)
 		if err != nil {
 			continue
 		}
@@ -92,7 +94,7 @@ func (b *Bridge) heartbeat() {
 		if time.Now().After(nextTime) {
 			b.SendMetric(metrics.New(metrics.Heartbeat, metrics.Daily, metrics.NoLabel))
 			nextTime = nextTime.Add(24 * time.Hour)
-			b.pref.Set(preferences.NextHeartbeatKey, strconv.FormatInt(nextTime.Unix(), 10))
+			b.settings.Set(settings.NextHeartbeatKey, strconv.FormatInt(nextTime.Unix(), 10))
 		}
 	}
 }

internal/bridge/credits.go

@@ -15,8 +15,8 @@
 // You should have received a copy of the GNU General Public License
 // along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
 
-// Code generated by ./credits.sh at Mon Dec 28 02:39:43 PM CET 2020. DO NOT EDIT.
+// Code generated by ./credits.sh at Mon Jan 4 03:19:07 PM CET 2021. DO NOT EDIT.
 
 package bridge
 
-const Credits = "github.com/0xAX/notificator;github.com/abiosoft/ishell;github.com/abiosoft/readline;github.com/allan-simon/go-singleinstance;github.com/chzyer/logex;github.com/chzyer/test;github.com/cucumber/godog;github.com/docker/docker-credential-helpers;github.com/emersion/go-imap;github.com/emersion/go-imap-appendlimit;github.com/emersion/go-imap-idle;github.com/emersion/go-imap-move;github.com/emersion/go-imap-quota;github.com/emersion/go-imap-unselect;github.com/emersion/go-mbox;github.com/emersion/go-message;github.com/emersion/go-sasl;github.com/emersion/go-smtp;github.com/emersion/go-textwrapper;github.com/emersion/go-vcard;github.com/fatih/color;github.com/flynn-archive/go-shlex;github.com/getsentry/sentry-go;github.com/golang/mock;github.com/google/go-cmp;github.com/google/uuid;github.com/gopherjs/gopherjs;github.com/go-resty/resty/v2;github.com/hashicorp/go-multierror;github.com/jameskeane/bcrypt;github.com/jaytaylor/html2text;github.com/kardianos/osext;github.com/keybase/go-keychain;github.com/logrusorgru/aurora;github.com/Masterminds/semver/v3;github.com/mattn/go-runewidth;github.com/miekg/dns;github.com/myesui/uuid;github.com/nsf/jsondiff;github.com/olekukonko/tablewriter;github.com/pkg/errors;github.com/ProtonMail/bcrypt;github.com/ProtonMail/crypto;github.com/ProtonMail/docker-credential-helpers;github.com/ProtonMail/go-appdir;github.com/ProtonMail/go-apple-mobileconfig;github.com/ProtonMail/go-autostart;github.com/ProtonMail/go-imap;github.com/ProtonMail/go-imap-id;github.com/ProtonMail/gopenpgp/v2;github.com/ProtonMail/go-rfc5322;github.com/ProtonMail/go-vcard;github.com/PuerkitoBio/goquery;github.com/sirupsen/logrus;github.com/skratchdot/open-golang;github.com/ssor/bom;github.com/stretchr/testify;github.com/therecipe/qt;github.com/twinj/uuid;github.com/urfave/cli;go.etcd.io/bbolt;golang.org/x/crypto;golang.org/x/net;golang.org/x/text;gopkg.in/stretchr/testify.v1;;Font Awesome 4.7.0;;Qt 5.13 by Qt group;"
+const Credits = "github.com/0xAX/notificator;github.com/abiosoft/ishell;github.com/abiosoft/readline;github.com/allan-simon/go-singleinstance;github.com/chzyer/logex;github.com/chzyer/test;github.com/cucumber/godog;github.com/docker/docker-credential-helpers;github.com/emersion/go-imap;github.com/emersion/go-imap-appendlimit;github.com/emersion/go-imap-idle;github.com/emersion/go-imap-move;github.com/emersion/go-imap-quota;github.com/emersion/go-imap-specialuse;github.com/emersion/go-imap-unselect;github.com/emersion/go-mbox;github.com/emersion/go-message;github.com/emersion/go-sasl;github.com/emersion/go-smtp;github.com/emersion/go-textwrapper;github.com/emersion/go-vcard;github.com/fatih/color;github.com/flynn-archive/go-shlex;github.com/getsentry/sentry-go;github.com/golang/mock;github.com/google/go-cmp;github.com/google/uuid;github.com/gopherjs/gopherjs;github.com/go-resty/resty/v2;github.com/hashicorp/go-multierror;github.com/jameskeane/bcrypt;github.com/jaytaylor/html2text;github.com/keybase/go-keychain;github.com/logrusorgru/aurora;github.com/Masterminds/semver/v3;github.com/mattn/go-runewidth;github.com/miekg/dns;github.com/myesui/uuid;github.com/nsf/jsondiff;github.com/olekukonko/tablewriter;github.com/pkg/errors;github.com/ProtonMail/bcrypt;github.com/ProtonMail/crypto;github.com/ProtonMail/docker-credential-helpers;github.com/ProtonMail/go-appdir;github.com/ProtonMail/go-apple-mobileconfig;github.com/ProtonMail/go-autostart;github.com/ProtonMail/go-imap;github.com/ProtonMail/go-imap-id;github.com/ProtonMail/gopenpgp/v2;github.com/ProtonMail/go-rfc5322;github.com/ProtonMail/go-vcard;github.com/PuerkitoBio/goquery;github.com/sirupsen/logrus;github.com/skratchdot/open-golang;github.com/ssor/bom;github.com/stretchr/testify;github.com/therecipe/qt;github.com/twinj/uuid;github.com/urfave/cli/v2;go.etcd.io/bbolt;golang.org/x/crypto;golang.org/x/net;golang.org/x/text;gopkg.in/stretchr/testify.v1;;Font Awesome 4.7.0;;Qt 5.13 by Qt group;"

internal/bridge/store_factory.go

@@ -28,7 +28,7 @@ import (
 )
 
 type storeFactory struct {
-	config        StoreFactoryConfiger
+	cache         Cacher
 	panicHandler  users.PanicHandler
 	clientManager users.ClientManager
 	eventListener listener.Listener
@@ -36,29 +36,29 @@ type storeFactory struct {
 }
 
 func newStoreFactory(
-	config StoreFactoryConfiger,
+	cache Cacher,
 	panicHandler users.PanicHandler,
 	clientManager users.ClientManager,
 	eventListener listener.Listener,
 ) *storeFactory {
 	return &storeFactory{
-		config:        config,
+		cache:         cache,
 		panicHandler:  panicHandler,
 		clientManager: clientManager,
 		eventListener: eventListener,
-		storeCache:    store.NewCache(config.GetIMAPCachePath()),
+		storeCache:    store.NewCache(cache.GetIMAPCachePath()),
 	}
 }
 
 // New creates new store for given user.
 func (f *storeFactory) New(user store.BridgeUser) (*store.Store, error) {
-	storePath := getUserStorePath(f.config.GetDBDir(), user.ID())
+	storePath := getUserStorePath(f.cache.GetDBDir(), user.ID())
 	return store.New(f.panicHandler, user, f.clientManager, f.eventListener, storePath, f.storeCache)
 }
 
 // Remove removes all store files for given user.
 func (f *storeFactory) Remove(userID string) error {
-	storePath := getUserStorePath(f.config.GetDBDir(), userID)
+	storePath := getUserStorePath(f.cache.GetDBDir(), userID)
 	return store.RemoveStore(f.storeCache, storePath, userID)
 }
 

internal/bridge/types.go

@@ -17,22 +17,18 @@
 
 package bridge
 
-import "github.com/ProtonMail/proton-bridge/internal/users"
-
-type Configer interface {
-	users.Configer
-	StoreFactoryConfiger
+type Locator interface {
+	Clear() error
 }
 
-type StoreFactoryConfiger interface {
-	GetDBDir() string
+type Cacher interface {
 	GetIMAPCachePath() string
+	GetDBDir() string
 }
 
-type PreferenceProvider interface {
+type SettingsProvider interface {
 	Get(key string) string
+	Set(key string, value string)
 	GetBool(key string) bool
 	SetBool(key string, val bool)
-	GetInt(key string) int
-	Set(key string, value string)
 }

internal/cmd/main.go

@@ -1,96 +0,0 @@
-// Copyright (c) 2021 Proton Technologies AG
-//
-// This file is part of ProtonMail Bridge.
-//
-// ProtonMail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// ProtonMail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package cmd
-
-import (
-	"os"
-	"runtime"
-
-	"github.com/ProtonMail/proton-bridge/pkg/constants"
-	pkgSentry "github.com/ProtonMail/proton-bridge/pkg/sentry"
-	"github.com/getsentry/sentry-go"
-	"github.com/sirupsen/logrus"
-	"github.com/urfave/cli"
-)
-
-var (
-	log = logrus.WithField("pkg", "cmd") //nolint[gochecknoglobals]
-
-	baseFlags = []cli.Flag{ //nolint[gochecknoglobals]
-		cli.StringFlag{
-			Name:  "log-level, l",
-			Usage: "Set the log level (one of panic, fatal, error, warn, info, debug, debug-client, debug-server)"},
-		cli.BoolFlag{
-			Name:  "cli, c",
-			Usage: "Use command line interface"},
-		cli.StringFlag{
-			Name:  "version-json, g",
-			Usage: "Generate json version file"},
-		cli.BoolFlag{
-			Name:  "mem-prof, m",
-			Usage: "Generate memory profile"},
-		cli.BoolFlag{
-			Name:  "cpu-prof, p",
-			Usage: "Generate CPU profile"},
-	}
-)
-
-// Main sets up Sentry, filters out unwanted args, creates app and runs it.
-func Main(appName, usage string, extraFlags []cli.Flag, run func(*cli.Context) error) {
-	err := sentry.Init(sentry.ClientOptions{
-		Dsn:        constants.DSNSentry,
-		Release:    constants.Revision,
-		BeforeSend: pkgSentry.EnhanceSentryEvent,
-	})
-
-	sentry.ConfigureScope(func(scope *sentry.Scope) {
-		scope.SetFingerprint([]string{"{{ default }}"})
-	})
-
-	if err != nil {
-		log.WithError(err).Errorln("Can not setup sentry DSN")
-	}
-
-	filterProcessSerialNumberFromArgs()
-	filterRestartNumberFromArgs()
-
-	app := newApp(appName, usage, extraFlags, run)
-
-	logrus.SetLevel(logrus.InfoLevel)
-	log.WithField("version", constants.Version).
-		WithField("revision", constants.Revision).
-		WithField("build", constants.BuildTime).
-		WithField("runtime", runtime.GOOS).
-		WithField("args", os.Args).
-		WithField("appName", app.Name).
-		Info("Run app")
-
-	if err := app.Run(os.Args); err != nil {
-		log.Error("Program exited with error: ", err)
-	}
-}
-
-func newApp(appName, usage string, extraFlags []cli.Flag, run func(*cli.Context) error) *cli.App {
-	app := cli.NewApp()
-	app.Name = appName
-	app.Usage = usage
-	app.Version = constants.BuildVersion
-	app.Flags = append(baseFlags, extraFlags...) //nolint[gocritic]
-	app.Action = run
-	return app
-}

internal/cmd/restart.go

@@ -1,111 +0,0 @@
-// Copyright (c) 2021 Proton Technologies AG
-//
-// This file is part of ProtonMail Bridge.
-//
-// ProtonMail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// ProtonMail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package cmd
-
-import (
-	"fmt"
-	"os"
-	"os/exec"
-	"strconv"
-	"strings"
-
-	"github.com/ProtonMail/proton-bridge/internal/frontend"
-	"github.com/ProtonMail/proton-bridge/pkg/config"
-	"github.com/ProtonMail/proton-bridge/pkg/sentry"
-	"github.com/urfave/cli"
-)
-
-const (
-	// After how many crashes app gives up starting.
-	maxAllowedCrashes = 10
-)
-
-var (
-	// How many crashes happened so far in a row.
-	// It will be filled from args by `filterRestartNumberFromArgs`.
-	// Every call of `HandlePanic` will increase this number.
-	// Then it will be passed as argument to the next try by `RestartApp`.
-	numberOfCrashes = 0 //nolint[gochecknoglobals]
-)
-
-// filterRestartNumberFromArgs removes flag with a number how many restart we already did.
-// See restartApp how that number is used.
-func filterRestartNumberFromArgs() {
-	tmp := os.Args[:0]
-	for i, arg := range os.Args {
-		if !strings.HasPrefix(arg, "--restart_") {
-			tmp = append(tmp, arg)
-			continue
-		}
-		var err error
-		numberOfCrashes, err = strconv.Atoi(os.Args[i][10:])
-		if err != nil {
-			numberOfCrashes = maxAllowedCrashes
-		}
-	}
-	os.Args = tmp
-}
-
-// DisableRestart disables restart once `RestartApp` is called.
-func DisableRestart() {
-	numberOfCrashes = maxAllowedCrashes
-}
-
-// RestartApp starts a new instance in background.
-func RestartApp() {
-	if numberOfCrashes >= maxAllowedCrashes {
-		log.Error("Too many crashes")
-		return
-	}
-	if exeFile, err := os.Executable(); err == nil {
-		arguments := append(os.Args[1:], fmt.Sprintf("--restart_%d", numberOfCrashes))
-		cmd := exec.Command(exeFile, arguments...) //nolint[gosec]
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		cmd.Stdin = os.Stdin
-		if err := cmd.Start(); err != nil {
-			log.Error("Restart failed: ", err)
-		}
-	}
-}
-
-// PanicHandler defines HandlePanic which can be used anywhere in defer.
-type PanicHandler struct {
-	AppName string
-	Config  *config.Config
-	Err     *error // Pointer to error of cli action.
-}
-
-// HandlePanic should be called in defer to ensure restart of app after error.
-func (ph *PanicHandler) HandlePanic() {
-	sentry.SkipDuringUnwind()
-
-	r := recover()
-	if r == nil {
-		return
-	}
-
-	config.HandlePanic(ph.Config, fmt.Sprintf("Recover: %v", r))
-	frontend.HandlePanic(ph.AppName)
-
-	*ph.Err = cli.NewExitError("Panic and restart", 255)
-	numberOfCrashes++
-	log.Error("Restarting after panic")
-	RestartApp()
-	os.Exit(255)
-}

internal/config/cache/cache.go

@@ -0,0 +1,65 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+// Package cache provides access to contents inside a cache directory.
+package cache
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/ProtonMail/proton-bridge/pkg/files"
+)
+
+type Cache struct {
+	dir, version string
+}
+
+func New(dir, version string) (*Cache, error) {
+	if err := os.MkdirAll(filepath.Join(dir, version), 0700); err != nil {
+		return nil, err
+	}
+
+	return &Cache{
+		dir:     dir,
+		version: version,
+	}, nil
+}
+
+// GetDBDir returns folder for db files.
+func (c *Cache) GetDBDir() string {
+	return c.getCurrentCacheDir()
+}
+
+// GetIMAPCachePath returns path to file with IMAP status.
+func (c *Cache) GetIMAPCachePath() string {
+	return filepath.Join(c.getCurrentCacheDir(), "user_info.json")
+}
+
+// GetTransferDir returns folder for import-export rules files.
+func (c *Cache) GetTransferDir() string {
+	return c.getCurrentCacheDir()
+}
+
+// RemoveOldVersions removes any cache dirs that are not the current version.
+func (c *Cache) RemoveOldVersions() error {
+	return files.Remove(c.dir).Except(c.getCurrentCacheDir()).Do()
+}
+
+func (c *Cache) getCurrentCacheDir() string {
+	return filepath.Join(c.dir, c.version)
+}

internal/config/cache/cache_test.go

@@ -0,0 +1,70 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package cache
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRemoveOldVersions(t *testing.T) {
+	dir, err := ioutil.TempDir("", "test-cache")
+	require.NoError(t, err)
+
+	cache, err := New(dir, "c4")
+	require.NoError(t, err)
+
+	createFilesInDir(t, dir,
+		"unexpected1.txt",
+		"c1/unexpected1.txt",
+		"c2/unexpected2.txt",
+		"c3/unexpected3.txt",
+		"something.txt",
+	)
+
+	require.DirExists(t, filepath.Join(dir, "c4"))
+	require.FileExists(t, filepath.Join(dir, "unexpected1.txt"))
+	require.FileExists(t, filepath.Join(dir, "c1", "unexpected1.txt"))
+	require.FileExists(t, filepath.Join(dir, "c2", "unexpected2.txt"))
+	require.FileExists(t, filepath.Join(dir, "c3", "unexpected3.txt"))
+	require.FileExists(t, filepath.Join(dir, "something.txt"))
+
+	assert.NoError(t, cache.RemoveOldVersions())
+
+	assert.DirExists(t, filepath.Join(dir, "c4"))
+	assert.NoFileExists(t, filepath.Join(dir, "unexpected1.txt"))
+	assert.NoFileExists(t, filepath.Join(dir, "c1", "unexpected1.txt"))
+	assert.NoFileExists(t, filepath.Join(dir, "c2", "unexpected2.txt"))
+	assert.NoFileExists(t, filepath.Join(dir, "c3", "unexpected3.txt"))
+	assert.NoFileExists(t, filepath.Join(dir, "something.txt"))
+}
+
+func createFilesInDir(t *testing.T, dir string, files ...string) {
+	for _, target := range files {
+		require.NoError(t, os.MkdirAll(filepath.Dir(filepath.Join(dir, target)), 0700))
+
+		f, err := os.Create(filepath.Join(dir, target))
+		require.NoError(t, err)
+		require.NoError(t, f.Close())
+	}
+}

internal/config/settings/kvs.go

@@ -0,0 +1,137 @@
+// Copyright (c) 2021 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package settings
+
+import (
+	"encoding/json"
+	"errors"
+	"os"
+	"strconv"
+	"sync"
+
+	"github.com/sirupsen/logrus"
+)
+
+type keyValueStore struct {
+	cache map[string]string
+	path  string
+	lock  *sync.RWMutex
+}
+
+// newKeyValueStore returns loaded preferences.
+func newKeyValueStore(path string) *keyValueStore {
+	p := &keyValueStore{
+		path: path,
+		lock: &sync.RWMutex{},
+	}
+	if err := p.load(); err != nil {
+		logrus.WithError(err).Warn("Cannot load preferences file, creating new one")
+	}
+	return p
+}
+
+func (p *keyValueStore) load() error {
+	if p.cache != nil {
+		return nil
+	}
+
+	p.lock.Lock()
+	defer p.lock.Unlock()
+
+	p.cache = map[string]string{}
+
+	f, err := os.Open(p.path)
+	if err != nil {
+		return err
+	}
+	defer f.Close() //nolint[errcheck]
+
+	return json.NewDecoder(f).Decode(&p.cache)
+}
+
+func (p *keyValueStore) save() error {
+	if p.cache == nil {
+		return errors.New("cannot save preferences: cache is nil")
+	}
+
+	p.lock.Lock()
+	defer p.lock.Unlock()
+
+	f, err := os.Create(p.path)
+	if err != nil {
+		return err
+	}
+	defer f.Close() //nolint[errcheck]
+
+	return json.NewEncoder(f).Encode(p.cache)
+}
+
+func (p *keyValueStore) setDefault(key, value string) {
+	if p.Get(key) == "" {
+		p.Set(key, value)
+	}
+}
+
+func (p *keyValueStore) Get(key string) string {
+	p.lock.RLock()
+	defer p.lock.RUnlock()
+
+	return p.cache[key]
+}
+
+func (p *keyValueStore) GetBool(key string) bool {
+	return p.Get(key) == "true"
+}
+
+func (p *keyValueStore) GetInt(key string) int {
+	value, err := strconv.Atoi(p.Get(key))
+	if err != nil {
+		logrus.WithError(err).Error("Cannot parse int")
+	}
+	return value
+}
+
+func (p *keyValueStore) GetFloat64(key string) float64 {
+	value, err := strconv.ParseFloat(p.Get(key), 64)
+	if err != nil {
+		logrus.WithError(err).Error("Cannot parse float64")
+	}
+	return value
+}
+
+func (p *keyValueStore) Set(key, value string) {
+	p.lock.Lock()
+	p.cache[key] = value
+	p.lock.Unlock()
+
+	if err := p.save(); err != nil {
+		logrus.WithError(err).Warn("Cannot save preferences")
+	}
+}
+
+func (p *keyValueStore) SetBool(key string, value bool) {
+	if value {
+		p.Set(key, "true")
+	} else {
+		p.Set(key, "false")
+	}
+}
+
+func (p *keyValueStore) SetInt(key string, value int) {
+	p.Set(key, strconv.Itoa(value))
+}

internal/config/settings/kvs_test.go

@@ -0,0 +1,105 @@
+// Copyright (c) 2021 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package settings
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+const testPrefFilePath = "/tmp/pref.json"
+
+func TestLoadNoKeyValueStore(t *testing.T) {
+	pref := newTestEmptyKeyValueStore(t)
+	require.Equal(t, "", pref.Get("key"))
+}
+
+func TestLoadBadKeyValueStore(t *testing.T) {
+	require.NoError(t, ioutil.WriteFile(testPrefFilePath, []byte("{\"key\":\"value"), 0700))
+	pref := newKeyValueStore(testPrefFilePath)
+	require.Equal(t, "", pref.Get("key"))
+}
+
+func TestKeyValueStoreGet(t *testing.T) {
+	pref := newTestKeyValueStore(t)
+	require.Equal(t, "value", pref.Get("str"))
+	require.Equal(t, "42", pref.Get("int"))
+	require.Equal(t, "true", pref.Get("bool"))
+	require.Equal(t, "t", pref.Get("falseBool"))
+}
+
+func TestKeyValueStoreGetInt(t *testing.T) {
+	pref := newTestKeyValueStore(t)
+	require.Equal(t, 0, pref.GetInt("str"))
+	require.Equal(t, 42, pref.GetInt("int"))
+	require.Equal(t, 0, pref.GetInt("bool"))
+	require.Equal(t, 0, pref.GetInt("falseBool"))
+}
+
+func TestKeyValueStoreGetBool(t *testing.T) {
+	pref := newTestKeyValueStore(t)
+	require.Equal(t, false, pref.GetBool("str"))
+	require.Equal(t, false, pref.GetBool("int"))
+	require.Equal(t, true, pref.GetBool("bool"))
+	require.Equal(t, false, pref.GetBool("falseBool"))
+}
+
+func TestKeyValueStoreSetDefault(t *testing.T) {
+	pref := newTestEmptyKeyValueStore(t)
+	pref.setDefault("key", "value")
+	pref.setDefault("key", "othervalue")
+	require.Equal(t, "value", pref.Get("key"))
+}
+
+func TestKeyValueStoreSet(t *testing.T) {
+	pref := newTestEmptyKeyValueStore(t)
+	pref.Set("str", "value")
+	checkSavedKeyValueStore(t, "{\"str\":\"value\"}")
+}
+
+func TestKeyValueStoreSetInt(t *testing.T) {
+	pref := newTestEmptyKeyValueStore(t)
+	pref.SetInt("int", 42)
+	checkSavedKeyValueStore(t, "{\"int\":\"42\"}")
+}
+
+func TestKeyValueStoreSetBool(t *testing.T) {
+	pref := newTestEmptyKeyValueStore(t)
+	pref.SetBool("trueBool", true)
+	pref.SetBool("falseBool", false)
+	checkSavedKeyValueStore(t, "{\"falseBool\":\"false\",\"trueBool\":\"true\"}")
+}
+
+func newTestEmptyKeyValueStore(t *testing.T) *keyValueStore {
+	require.NoError(t, os.RemoveAll(testPrefFilePath))
+	return newKeyValueStore(testPrefFilePath)
+}
+
+func newTestKeyValueStore(t *testing.T) *keyValueStore {
+	require.NoError(t, ioutil.WriteFile(testPrefFilePath, []byte("{\"str\":\"value\",\"int\":\"42\",\"bool\":\"true\",\"falseBool\":\"t\"}"), 0700))
+	return newKeyValueStore(testPrefFilePath)
+}
+
+func checkSavedKeyValueStore(t *testing.T, expected string) {
+	data, err := ioutil.ReadFile(testPrefFilePath)
+	require.NoError(t, err)
+	require.Equal(t, expected+"\n", string(data))
+}

internal/config/settings/settings.go

@@ -15,15 +15,14 @@
 // You should have received a copy of the GNU General Public License
 // along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
 
-// Package preferences provides key names and defaults for preferences used in Bridge.
-package preferences
+// Package settings provides access to persistent user settings.
+package settings
 
 import (
-	"strconv"
+	"fmt"
+	"math/rand"
+	"path/filepath"
 	"time"
-
-	"github.com/ProtonMail/proton-bridge/pkg/config"
-	"github.com/sirupsen/logrus"
 )
 
 // Keys of preferences in JSON file.
@@ -37,43 +36,51 @@ const (
 	SMTPSSLKey             = "user_ssl_smtp"
 	AllowProxyKey          = "allow_proxy"
 	AutostartKey           = "autostart"
+	AutoUpdateKey          = "autoupdate"
 	CookiesKey             = "cookies"
 	ReportOutgoingNoEncKey = "report_outgoing_email_without_encryption"
 	LastVersionKey         = "last_used_version"
+	RolloutKey             = "rollout"
 )
 
-type configProvider interface {
-	GetPreferencesPath() string
-	GetDefaultAPIPort() int
-	GetDefaultIMAPPort() int
-	GetDefaultSMTPPort() int
+type Settings struct {
+	*keyValueStore
+
+	settingsPath string
 }
 
-var log = logrus.WithField("pkg", "store") //nolint[gochecknoglobals]
+func New(settingsPath string) *Settings {
+	s := &Settings{
+		keyValueStore: newKeyValueStore(filepath.Join(settingsPath, "prefs.json")),
+		settingsPath:  settingsPath,
+	}
 
-// New returns loaded preferences with Bridge defaults when values are not set yet.
-func New(cfg configProvider) (pref *config.Preferences) {
-	path := cfg.GetPreferencesPath()
-	pref = config.NewPreferences(path)
-	setDefaults(pref, cfg)
+	s.setDefaultValues()
 
-	log.WithField("path", path).Trace("Opened preferences")
-
-	return
+	return s
 }
 
-func setDefaults(preferences *config.Preferences, cfg configProvider) {
-	preferences.SetDefault(FirstStartKey, "true")
-	preferences.SetDefault(FirstStartGUIKey, "true")
-	preferences.SetDefault(NextHeartbeatKey, strconv.FormatInt(time.Now().Unix(), 10))
-	preferences.SetDefault(APIPortKey, strconv.Itoa(cfg.GetDefaultAPIPort()))
-	preferences.SetDefault(IMAPPortKey, strconv.Itoa(cfg.GetDefaultIMAPPort()))
-	preferences.SetDefault(SMTPPortKey, strconv.Itoa(cfg.GetDefaultSMTPPort()))
-	preferences.SetDefault(AllowProxyKey, "true")
-	preferences.SetDefault(AutostartKey, "true")
-	preferences.SetDefault(ReportOutgoingNoEncKey, "false")
-	preferences.SetDefault(LastVersionKey, "")
+const (
+	DefaultIMAPPort = "1143"
+	DefaultSMTPPort = "1025"
+	DefaultAPIPort  = "1042"
+)
+
+func (s *Settings) setDefaultValues() {
+	s.setDefault(FirstStartKey, "true")
+	s.setDefault(FirstStartGUIKey, "true")
+	s.setDefault(NextHeartbeatKey, fmt.Sprintf("%v", time.Now().Unix()))
+	s.setDefault(AllowProxyKey, "true")
+	s.setDefault(AutostartKey, "true")
+	s.setDefault(AutoUpdateKey, "false")
+	s.setDefault(ReportOutgoingNoEncKey, "false")
+	s.setDefault(LastVersionKey, "")
+	s.setDefault(RolloutKey, fmt.Sprintf("%v", rand.Float64()))
+
+	s.setDefault(APIPortKey, DefaultAPIPort)
+	s.setDefault(IMAPPortKey, DefaultIMAPPort)
+	s.setDefault(SMTPPortKey, DefaultSMTPPort)
 
 	// By default, stick to STARTTLS. If the user uses catalina+applemail they'll have to change to SSL.
-	preferences.SetDefault(SMTPSSLKey, "false")
+	s.setDefault(SMTPSSLKey, "false")
 }

internal/config/tls/tls.go

@@ -0,0 +1,191 @@
+// Copyright (c) 2021 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package tls
+
+import (
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/tls"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"fmt"
+	"math/big"
+	"net"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"time"
+
+	"github.com/sirupsen/logrus"
+)
+
+type TLS struct {
+	settingsPath string
+}
+
+func New(settingsPath string) *TLS {
+	return &TLS{
+		settingsPath: settingsPath,
+	}
+}
+
+var tlsTemplate = x509.Certificate{ //nolint[gochecknoglobals]
+	SerialNumber: big.NewInt(-1),
+	Subject: pkix.Name{
+		Country:            []string{"CH"},
+		Organization:       []string{"Proton Technologies AG"},
+		OrganizationalUnit: []string{"ProtonMail"},
+		CommonName:         "127.0.0.1",
+	},
+	KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
+	ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth},
+	BasicConstraintsValid: true,
+	IsCA:                  true,
+	IPAddresses:           []net.IP{net.ParseIP("127.0.0.1")},
+	NotBefore:             time.Now(),
+	NotAfter:              time.Now().Add(20 * 365 * 24 * time.Hour),
+}
+
+var ErrTLSCertExpireSoon = fmt.Errorf("TLS certificate will expire soon")
+
+// getTLSCertPath returns path to certificate; used for TLS servers (IMAP, SMTP).
+func (t *TLS) getTLSCertPath() string {
+	return filepath.Join(t.settingsPath, "cert.pem")
+}
+
+// getTLSKeyPath returns path to private key; used for TLS servers (IMAP, SMTP).
+func (t *TLS) getTLSKeyPath() string {
+	return filepath.Join(t.settingsPath, "key.pem")
+}
+
+// GenerateConfig generates certs and keys at the given filepaths and returns a TLS Config which holds them.
+// See https://golang.org/src/crypto/tls/generate_cert.go
+func (t *TLS) GenerateConfig() (tlsConfig *tls.Config, err error) {
+	priv, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		err = fmt.Errorf("failed to generate private key: %s", err)
+		return
+	}
+
+	serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
+	serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
+	if err != nil {
+		err = fmt.Errorf("failed to generate serial number: %s", err)
+		return
+	}
+
+	tlsTemplate.SerialNumber = serialNumber
+	derBytes, err := x509.CreateCertificate(rand.Reader, &tlsTemplate, &tlsTemplate, &priv.PublicKey, priv)
+	if err != nil {
+		err = fmt.Errorf("failed to create certificate: %s", err)
+		return
+	}
+
+	certOut, err := os.Create(t.getTLSCertPath())
+	if err != nil {
+		return
+	}
+	defer certOut.Close() //nolint[errcheck]
+	err = pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
+	if err != nil {
+		return
+	}
+
+	keyOut, err := os.OpenFile(t.getTLSKeyPath(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
+	if err != nil {
+		return
+	}
+	defer keyOut.Close() //nolint[errcheck]
+	err = pem.Encode(keyOut, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(priv)})
+	if err != nil {
+		return
+	}
+
+	return loadTLSConfig(t.getTLSCertPath(), t.getTLSKeyPath())
+}
+
+// GetConfig tries to load TLS config or generate new one which is then returned.
+func (t *TLS) GetConfig() (tlsConfig *tls.Config, err error) {
+	certPath := t.getTLSCertPath()
+	keyPath := t.getTLSKeyPath()
+	tlsConfig, err = loadTLSConfig(certPath, keyPath)
+	if err != nil {
+		logrus.WithError(err).Warn("Cannot load cert, generating a new one")
+		tlsConfig, err = t.GenerateConfig()
+		if err != nil {
+			return
+		}
+
+		if runtime.GOOS == "darwin" {
+			if err := exec.Command( // nolint[gosec]
+				"/usr/bin/security",
+				"execute-with-privileges",
+				"/usr/bin/security",
+				"add-trusted-cert",
+				"-d",
+				"-r", "trustRoot",
+				"-p", "ssl",
+				"-k", "/Library/Keychains/System.keychain",
+				certPath,
+			).Run(); err != nil {
+				logrus.WithError(err).Error("Failed to add cert to system keychain")
+			}
+		}
+	}
+
+	tlsConfig.ServerName = "127.0.0.1"
+	tlsConfig.ClientAuth = tls.VerifyClientCertIfGiven
+
+	caCertPool := x509.NewCertPool()
+	caCertPool.AddCert(tlsConfig.Certificates[0].Leaf)
+	tlsConfig.RootCAs = caCertPool
+	tlsConfig.ClientCAs = caCertPool
+
+	/* This is deprecated:
+	 * SA1019: tlsConfig.BuildNameToCertificate is deprecated:
+	 * NameToCertificate only allows associating a single certificate with a given name.
+	 * Leave that field nil to let the library select the first compatible chain from Certificates.
+	 */
+	tlsConfig.BuildNameToCertificate() // nolint[staticcheck]
+
+	return tlsConfig, err
+}
+
+func loadTLSConfig(certPath, keyPath string) (tlsConfig *tls.Config, err error) {
+	c, err := tls.LoadX509KeyPair(certPath, keyPath)
+	if err != nil {
+		return
+	}
+
+	c.Leaf, err = x509.ParseCertificate(c.Certificate[0])
+	if err != nil {
+		return
+	}
+
+	tlsConfig = &tls.Config{
+		Certificates: []tls.Certificate{c},
+	}
+
+	if time.Now().Add(31 * 24 * time.Hour).After(c.Leaf.NotAfter) {
+		err = ErrTLSCertExpireSoon
+		return
+	}
+	return
+}

internal/config/tls/tls_test.go

@@ -0,0 +1,64 @@
+// Copyright (c) 2021 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package tls
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestTLSKeyRenewal(t *testing.T) {
+	// Remove keys.
+	configPath := "/tmp"
+	certPath := filepath.Join(configPath, "cert.pem")
+	keyPath := filepath.Join(configPath, "key.pem")
+	_ = os.Remove(certPath)
+	_ = os.Remove(keyPath)
+
+	dir, err := ioutil.TempDir("", "test-tls")
+	require.NoError(t, err)
+
+	tls := New(dir)
+
+	// Put old key there.
+	tlsTemplate.NotBefore = time.Now().Add(-365 * 24 * time.Hour)
+	tlsTemplate.NotAfter = time.Now()
+	cert, err := tls.GenerateConfig()
+	require.Equal(t, err, ErrTLSCertExpireSoon)
+	require.Equal(t, len(cert.Certificates), 1)
+	time.Sleep(time.Second)
+	now, notValidAfter := time.Now(), cert.Certificates[0].Leaf.NotAfter
+	require.True(t, now.After(notValidAfter), "old certificate expected to not be valid at %v but have valid until %v", now, notValidAfter)
+
+	// Renew key.
+	tlsTemplate.NotBefore = time.Now()
+	tlsTemplate.NotAfter = time.Now().Add(2 * 365 * 24 * time.Hour)
+	cert, err = tls.GetConfig()
+	if runtime.GOOS != "darwin" { // Darwin is not supported.
+		require.NoError(t, err)
+	}
+	require.Equal(t, len(cert.Certificates), 1)
+	now, notValidAfter = time.Now(), cert.Certificates[0].Leaf.NotAfter
+	require.False(t, now.After(notValidAfter), "new certificate expected to be valid at %v but have valid until %v", now, notValidAfter)
+}

internal/constants/constants.go

@@ -0,0 +1,41 @@
+// Copyright (c) 2021 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+// Package constants contains variables that are set via ldflags during build.
+package constants
+
+import "fmt"
+
+const VendorName = "protonmail"
+
+// nolint[gochecknoglobals]
+var (
+	// Version of the build.
+	Version = ""
+
+	// Revision is current hash of the build.
+	Revision = ""
+
+	// BuildTime stamp of the build.
+	BuildTime = ""
+
+	// DSNSentry client keys to be able to report crashes to Sentry.
+	DSNSentry = ""
+
+	// BuildVersion is derived from LongVersion and BuildTime.
+	BuildVersion = fmt.Sprintf("%v (%v) %v", Version, Revision, BuildTime)
+)

internal/cookies/pantry.go

@@ -22,7 +22,7 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/ProtonMail/proton-bridge/internal/preferences"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
 )
 
 // pantry persists and loads cookies to some persistent storage location.
@@ -63,7 +63,7 @@ func (p *pantry) discardExpiredCookies() error {
 type cookiesByHost map[string][]*http.Cookie
 
 func (p *pantry) loadFromJSON() (cookiesByHost, error) {
-	b := p.gs.Get(preferences.CookiesKey)
+	b := p.gs.Get(settings.CookiesKey)
 
 	if b == "" {
 		return make(cookiesByHost), nil
@@ -84,7 +84,7 @@ func (p *pantry) saveToJSON(cookies cookiesByHost) error {
 		return err
 	}
 
-	p.gs.Set(preferences.CookiesKey, string(b))
+	p.gs.Set(settings.CookiesKey, string(b))
 
 	return nil
 }

internal/crash/actions.go

@@ -0,0 +1,42 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package crash
+
+import (
+	"fmt"
+
+	"github.com/0xAX/notificator"
+)
+
+// ShowErrorNotification shows a system notification that the app with the given appName has crashed.
+// NOTE: Icons shouldn't be hardcoded.
+func ShowErrorNotification(appName string) RecoveryAction {
+	return func(r interface{}) error {
+		notify := notificator.New(notificator.Options{
+			DefaultIcon: "../frontend/ui/icon/icon.png",
+			AppName:     appName,
+		})
+
+		return notify.Push(
+			"Fatal Error",
+			fmt.Sprintf("%v has encountered a fatal error.", appName),
+			"/frontend/icon/icon.png",
+			notificator.UR_CRITICAL,
+		)
+	}
+}

internal/crash/handler.go

@@ -0,0 +1,54 @@
+// Copyright (c) 2021 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+// Package crash implements a crash handler with configurable recovery actions.
+package crash
+
+import (
+	"github.com/ProtonMail/proton-bridge/pkg/sentry"
+	"github.com/sirupsen/logrus"
+)
+
+type RecoveryAction func(interface{}) error
+
+type Handler struct {
+	actions []RecoveryAction
+}
+
+func NewHandler(actions ...RecoveryAction) *Handler {
+	return &Handler{actions: actions}
+}
+
+func (h *Handler) AddRecoveryAction(action RecoveryAction) *Handler {
+	h.actions = append(h.actions, action)
+	return h
+}
+
+func (h *Handler) HandlePanic() {
+	sentry.SkipDuringUnwind()
+
+	r := recover()
+	if r == nil {
+		return
+	}
+
+	for _, action := range h.actions {
+		if err := action(r); err != nil {
+			logrus.WithError(err).Error("Failed to execute recovery action")
+		}
+	}
+}

internal/crash/handler_test.go

@@ -15,36 +15,44 @@
 // You should have received a copy of the GNU General Public License
 // along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
 
-package updates
+package crash
 
-const (
-	InfoCurrentVersion = 1 + iota
-	InfoDownloading
-	InfoVerifying
-	InfoUnpacking
-	InfoUpgrading
-	InfoQuitApp
-	InfoRestartApp
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
-type Progress struct {
-	Processed   float32 // fraction of finished procedure [0.0-1.0]
-	Description int     // description by code (needs to be translated anyway)
-	Err         error   // occurred error
-	channel     chan<- Progress
-}
+func TestHandler(t *testing.T) {
+	var s string
 
-func (s *Progress) Update() {
-	s.channel <- *s
-}
+	h := NewHandler(
+		func(r interface{}) error {
+			s += fmt.Sprintf("1: %v\n", r)
+			return nil
+		},
+		func(r interface{}) error {
+			s += fmt.Sprintf("2: %v\n", r)
+			return nil
+		},
+	)
 
-func (s *Progress) UpdateDescription(description int) {
-	s.Description = description
-	s.Processed = 0
-	s.Update()
-}
+	h.
+		AddRecoveryAction(func(r interface{}) error {
+			s += fmt.Sprintf("3: %v\n", r)
+			return nil
+		}).
+		AddRecoveryAction(func(r interface{}) error {
+			s += fmt.Sprintf("4: %v\n", r)
+			return nil
+		})
 
-func (s *Progress) UpdateProcessed(processed float32) {
-	s.Processed = processed
-	s.Update()
+	defer func() {
+		assert.Equal(t, "1: thing\n2: thing\n3: thing\n4: thing\n", s)
+	}()
+
+	defer h.HandlePanic()
+
+	panic("thing")
 }

internal/events/events.go

@@ -27,6 +27,7 @@ import (
 // Constants of events used by the event listener in bridge.
 const (
 	ErrorEvent                   = "error"
+	CredentialsErrorEvent        = "credentialsError"
 	CloseConnectionEvent         = "closeConnection"
 	LogoutEvent                  = "logout"
 	AddressChangedEvent          = "addressChanged"
@@ -50,4 +51,5 @@ func SetupEvents(listener listener.Listener) {
 	listener.SetLimit(LogoutEvent, LogoutEventTimeout)
 	listener.SetBuffer(TLSCertIssue)
 	listener.SetBuffer(ErrorEvent)
+	listener.SetBuffer(CredentialsErrorEvent)
 }

internal/frontend/cli-ie/frontend.go

@@ -21,7 +21,8 @@ package cliie
 import (
 	"github.com/ProtonMail/proton-bridge/internal/events"
 	"github.com/ProtonMail/proton-bridge/internal/frontend/types"
-	"github.com/ProtonMail/proton-bridge/pkg/config"
+	"github.com/ProtonMail/proton-bridge/internal/locations"
+	"github.com/ProtonMail/proton-bridge/internal/updater"
 	"github.com/ProtonMail/proton-bridge/pkg/listener"
 
 	"github.com/abiosoft/ishell"
@@ -35,31 +36,33 @@ var (
 type frontendCLI struct {
 	*ishell.Shell
 
-	config        *config.Config
+	locations     *locations.Locations
 	eventListener listener.Listener
-	updates       types.Updater
+	updater       types.Updater
 	ie            types.ImportExporter
 
-	appRestart bool
+	restarter types.Restarter
 }
 
 // New returns a new CLI frontend configured with the given options.
 func New( //nolint[funlen]
 	panicHandler types.PanicHandler,
-	config *config.Config,
+
+	locations *locations.Locations,
 	eventListener listener.Listener,
-	updates types.Updater,
+	updater types.Updater,
 	ie types.ImportExporter,
+	restarter types.Restarter,
 ) *frontendCLI { //nolint[golint]
 	fe := &frontendCLI{
 		Shell: ishell.New(),
 
-		config:        config,
+		locations:     locations,
 		eventListener: eventListener,
-		updates:       updates,
+		updater:       updater,
 		ie:            ie,
 
-		appRestart: false,
+		restarter: restarter,
 	}
 
 	// Clear commands.
@@ -175,13 +178,12 @@ func New( //nolint[funlen]
 		defer panicHandler.HandlePanic()
 		fe.watchEvents()
 	}()
-	fe.eventListener.RetryEmit(events.TLSCertIssue)
-	fe.eventListener.RetryEmit(events.ErrorEvent)
 	return fe
 }
 
 func (f *frontendCLI) watchEvents() {
 	errorCh := f.getEventChannel(events.ErrorEvent)
+	credentialsErrorCh := f.getEventChannel(events.CredentialsErrorEvent)
 	internetOffCh := f.getEventChannel(events.InternetOffEvent)
 	internetOnCh := f.getEventChannel(events.InternetOnEvent)
 	addressChangedLogoutCh := f.getEventChannel(events.AddressChangedLogoutEvent)
@@ -191,6 +193,8 @@ func (f *frontendCLI) watchEvents() {
 		select {
 		case errorDetails := <-errorCh:
 			f.Println("Import-Export failed:", errorDetails)
+		case <-credentialsErrorCh:
+			f.notifyCredentialsError()
 		case <-internetOffCh:
 			f.notifyInternetOff()
 		case <-internetOnCh:
@@ -212,21 +216,12 @@ func (f *frontendCLI) watchEvents() {
 func (f *frontendCLI) getEventChannel(event string) <-chan string {
 	ch := make(chan string)
 	f.eventListener.Add(event, ch)
+	f.eventListener.RetryEmit(event)
 	return ch
 }
 
-// IsAppRestarting returns whether the app is currently set to restart.
-func (f *frontendCLI) IsAppRestarting() bool {
-	return f.appRestart
-}
-
 // Loop starts the frontend loop with an interactive shell.
-func (f *frontendCLI) Loop(credentialsError error) error {
-	if credentialsError != nil {
-		f.notifyCredentialsError()
-		return credentialsError
-	}
-
+func (f *frontendCLI) Loop() error {
 	f.Print(`
 Welcome to ProtonMail Import-Export app interactive shell
 
@@ -235,3 +230,8 @@ WARNING: The CLI is an experimental feature and does not yet cover all functiona
 	f.Run()
 	return nil
 }
+
+func (f *frontendCLI) NotifyManualUpdate(update updater.VersionInfo) error {
+	// NOTE: Save the update somewhere so that it can be installed when user chooses "install now".
+	return nil
+}

internal/frontend/cli-ie/system.go

@@ -24,7 +24,7 @@ import (
 func (f *frontendCLI) restart(c *ishell.Context) {
 	if f.yesNoQuestion("Are you sure you want to restart the Import-Export app") {
 		f.Println("Restarting the Import-Export app...")
-		f.appRestart = true
+		f.restarter.SetToRestart()
 		f.Stop()
 	}
 }
@@ -38,7 +38,11 @@ func (f *frontendCLI) checkInternetConnection(c *ishell.Context) {
 }
 
 func (f *frontendCLI) printLogDir(c *ishell.Context) {
-	f.Println("Log files are stored in\n\n ", f.config.GetLogDir())
+	if path, err := f.locations.ProvideLogsPath(); err != nil {
+		f.Println("Failed to determine location of log files")
+	} else {
+		f.Println("Log files are stored in\n\n ", path)
+	}
 }
 
 func (f *frontendCLI) printManual(c *ishell.Context) {

internal/frontend/cli-ie/updates.go

@@ -21,41 +21,15 @@ import (
 	"strings"
 
 	"github.com/ProtonMail/proton-bridge/internal/importexport"
-	"github.com/ProtonMail/proton-bridge/internal/updates"
 	"github.com/abiosoft/ishell"
 )
 
 func (f *frontendCLI) checkUpdates(c *ishell.Context) {
-	isUpToDate, latestVersionInfo, err := f.updates.CheckIsUpToDate()
-	if err != nil {
-		f.printAndLogError("Cannot retrieve version info: ", err)
-		f.checkInternetConnection(c)
-		return
-	}
-	if isUpToDate {
-		f.Println("Your version is up to date.")
-	} else {
-		f.notifyNeedUpgrade()
-		f.Println("")
-		f.printReleaseNotes(latestVersionInfo)
-	}
+	f.Println("Your version is up to date.")
 }
 
 func (f *frontendCLI) printLocalReleaseNotes(c *ishell.Context) {
-	localVersion := f.updates.GetLocalVersion()
-	f.printReleaseNotes(localVersion)
-}
-
-func (f *frontendCLI) printReleaseNotes(versionInfo updates.VersionInfo) {
-	f.Println(bold("ProtonMail Import-Export app "+versionInfo.Version), "\n")
-	if versionInfo.ReleaseNotes != "" {
-		f.Println(bold("Release Notes"))
-		f.Println(versionInfo.ReleaseNotes)
-	}
-	if versionInfo.ReleaseFixedBugs != "" {
-		f.Println(bold("Fixed bugs"))
-		f.Println(versionInfo.ReleaseFixedBugs)
-	}
+	f.Println("TODO")
 }
 
 func (f *frontendCLI) printCredits(c *ishell.Context) {

internal/frontend/cli-ie/utils.go

@@ -93,10 +93,10 @@ func (f *frontendCLI) notifyLogout(address string) {
 }
 
 func (f *frontendCLI) notifyNeedUpgrade() {
-	f.Println("Please download and install the newest version of application from", f.updates.GetDownloadLink())
+	f.Println("TODO")
 }
 
-func (f *frontendCLI) notifyCredentialsError() {
+func (f *frontendCLI) notifyCredentialsError() { // nolint[unused]
 	// Print in 80-column width.
 	f.Println("ProtonMail Import-Export app is not able to detect a supported password manager")
 	f.Println("(pass, gnome-keyring). Please install and set up a supported password manager")

internal/frontend/cli/accounts.go

@@ -21,8 +21,8 @@ import (
 	"strings"
 
 	"github.com/ProtonMail/proton-bridge/internal/bridge"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
 	"github.com/ProtonMail/proton-bridge/internal/frontend/types"
-	"github.com/ProtonMail/proton-bridge/internal/preferences"
 	"github.com/abiosoft/ishell"
 )
 
@@ -65,13 +65,13 @@ func (f *frontendCLI) showAccountInfo(c *ishell.Context) {
 
 func (f *frontendCLI) showAccountAddressInfo(user types.User, address string) {
 	smtpSecurity := "STARTTLS"
-	if f.preferences.GetBool(preferences.SMTPSSLKey) {
+	if f.settings.GetBool(settings.SMTPSSLKey) {
 		smtpSecurity = "SSL"
 	}
 	f.Println(bold("Configuration for " + address))
 	f.Printf("IMAP Settings\nAddress:   %s\nIMAP port: %d\nUsername:  %s\nPassword:  %s\nSecurity:  %s\n",
 		bridge.Host,
-		f.preferences.GetInt(preferences.IMAPPortKey),
+		f.settings.GetInt(settings.IMAPPortKey),
 		address,
 		user.GetBridgePassword(),
 		"STARTTLS",
@@ -79,7 +79,7 @@ func (f *frontendCLI) showAccountAddressInfo(user types.User, address string) {
 	f.Println("")
 	f.Printf("SMTP Settings\nAddress:   %s\nSMTP port: %d\nUsername:  %s\nPassword:  %s\nSecurity:  %s\n",
 		bridge.Host,
-		f.preferences.GetInt(preferences.SMTPPortKey),
+		f.settings.GetInt(settings.SMTPPortKey),
 		address,
 		user.GetBridgePassword(),
 		smtpSecurity,

internal/frontend/cli/frontend.go

@@ -19,9 +19,11 @@
 package cli
 
 import (
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
 	"github.com/ProtonMail/proton-bridge/internal/events"
 	"github.com/ProtonMail/proton-bridge/internal/frontend/types"
-	"github.com/ProtonMail/proton-bridge/pkg/config"
+	"github.com/ProtonMail/proton-bridge/internal/locations"
+	"github.com/ProtonMail/proton-bridge/internal/updater"
 	"github.com/ProtonMail/proton-bridge/pkg/listener"
 
 	"github.com/abiosoft/ishell"
@@ -35,34 +37,36 @@ var (
 type frontendCLI struct {
 	*ishell.Shell
 
-	config        *config.Config
-	preferences   *config.Preferences
+	locations     *locations.Locations
+	settings      *settings.Settings
 	eventListener listener.Listener
-	updates       types.Updater
+	updater       types.Updater
 	bridge        types.Bridger
 
-	appRestart bool
+	restarter types.Restarter
 }
 
 // New returns a new CLI frontend configured with the given options.
 func New( //nolint[funlen]
 	panicHandler types.PanicHandler,
-	config *config.Config,
-	preferences *config.Preferences,
+
+	locations *locations.Locations,
+	settings *settings.Settings,
 	eventListener listener.Listener,
-	updates types.Updater,
+	updater types.Updater,
 	bridge types.Bridger,
+	restarter types.Restarter,
 ) *frontendCLI { //nolint[golint]
 	fe := &frontendCLI{
 		Shell: ishell.New(),
 
-		config:        config,
-		preferences:   preferences,
+		locations:     locations,
+		settings:      settings,
 		eventListener: eventListener,
-		updates:       updates,
+		updater:       updater,
 		bridge:        bridge,
 
-		appRestart: false,
+		restarter: restarter,
 	}
 
 	// Clear commands.
@@ -185,13 +189,12 @@ func New( //nolint[funlen]
 		defer panicHandler.HandlePanic()
 		fe.watchEvents()
 	}()
-	fe.eventListener.RetryEmit(events.TLSCertIssue)
-	fe.eventListener.RetryEmit(events.ErrorEvent)
 	return fe
 }
 
 func (f *frontendCLI) watchEvents() {
 	errorCh := f.getEventChannel(events.ErrorEvent)
+	credentialsErrorCh := f.getEventChannel(events.CredentialsErrorEvent)
 	internetOffCh := f.getEventChannel(events.InternetOffEvent)
 	internetOnCh := f.getEventChannel(events.InternetOnEvent)
 	addressChangedCh := f.getEventChannel(events.AddressChangedEvent)
@@ -202,6 +205,8 @@ func (f *frontendCLI) watchEvents() {
 		select {
 		case errorDetails := <-errorCh:
 			f.Println("Bridge failed:", errorDetails)
+		case <-credentialsErrorCh:
+			f.notifyCredentialsError()
 		case <-internetOffCh:
 			f.notifyInternetOff()
 		case <-internetOnCh:
@@ -225,21 +230,12 @@ func (f *frontendCLI) watchEvents() {
 func (f *frontendCLI) getEventChannel(event string) <-chan string {
 	ch := make(chan string)
 	f.eventListener.Add(event, ch)
+	f.eventListener.RetryEmit(event)
 	return ch
 }
 
-// IsAppRestarting returns whether the app is currently set to restart.
-func (f *frontendCLI) IsAppRestarting() bool {
-	return f.appRestart
-}
-
 // Loop starts the frontend loop with an interactive shell.
-func (f *frontendCLI) Loop(credentialsError error) error {
-	if credentialsError != nil {
-		f.notifyCredentialsError()
-		return credentialsError
-	}
-
+func (f *frontendCLI) Loop() error {
 	f.Print(`
             Welcome to ProtonMail Bridge interactive shell
                               ___....___
@@ -260,3 +256,8 @@ func (f *frontendCLI) Loop(credentialsError error) error {
 	f.Run()
 	return nil
 }
+
+func (f *frontendCLI) NotifyManualUpdate(update updater.VersionInfo) error {
+	// NOTE: Save the update somewhere so that it can be installed when user chooses "install now".
+	return nil
+}

internal/frontend/cli/system.go

@@ -22,7 +22,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/ProtonMail/proton-bridge/internal/preferences"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
 	"github.com/ProtonMail/proton-bridge/pkg/ports"
 	"github.com/abiosoft/ishell"
 )
@@ -34,7 +34,7 @@ var (
 func (f *frontendCLI) restart(c *ishell.Context) {
 	if f.yesNoQuestion("Are you sure you want to restart the Bridge") {
 		f.Println("Restarting Bridge...")
-		f.appRestart = true
+		f.restarter.SetToRestart()
 		f.Stop()
 	}
 }
@@ -48,7 +48,11 @@ func (f *frontendCLI) checkInternetConnection(c *ishell.Context) {
 }
 
 func (f *frontendCLI) printLogDir(c *ishell.Context) {
-	f.Println("Log files are stored in\n\n ", f.config.GetLogDir())
+	if path, err := f.locations.ProvideLogsPath(); err != nil {
+		f.Println("Failed to determine location of log files")
+	} else {
+		f.Println("Log files are stored in\n\n ", path)
+	}
 }
 
 func (f *frontendCLI) printManual(c *ishell.Context) {
@@ -69,7 +73,7 @@ func (f *frontendCLI) deleteCache(c *ishell.Context) {
 	f.Println("Cached cleared, restarting bridge")
 	// Clearing data removes everything (db, preferences, ...)
 	// so everything has to be stopped and started again.
-	f.appRestart = true
+	f.restarter.SetToRestart()
 	f.Stop()
 }
 
@@ -77,7 +81,7 @@ func (f *frontendCLI) changeSMTPSecurity(c *ishell.Context) {
 	f.ShowPrompt(false)
 	defer f.ShowPrompt(true)
 
-	isSSL := f.preferences.GetBool(preferences.SMTPSSLKey)
+	isSSL := f.settings.GetBool(settings.SMTPSSLKey)
 	newSecurity := "SSL"
 	if isSSL {
 		newSecurity = "STARTTLS"
@@ -86,9 +90,9 @@ func (f *frontendCLI) changeSMTPSecurity(c *ishell.Context) {
 	msg := fmt.Sprintf("Are you sure you want to change SMTP setting to %q and restart the Bridge", newSecurity)
 
 	if f.yesNoQuestion(msg) {
-		f.preferences.SetBool(preferences.SMTPSSLKey, !isSSL)
+		f.settings.SetBool(settings.SMTPSSLKey, !isSSL)
 		f.Println("Restarting Bridge...")
-		f.appRestart = true
+		f.restarter.SetToRestart()
 		f.Stop()
 	}
 }
@@ -97,14 +101,14 @@ func (f *frontendCLI) changePort(c *ishell.Context) {
 	f.ShowPrompt(false)
 	defer f.ShowPrompt(true)
 
-	currentPort = f.preferences.Get(preferences.IMAPPortKey)
+	currentPort = f.settings.Get(settings.IMAPPortKey)
 	newIMAPPort := f.readStringInAttempts("Set IMAP port (current "+currentPort+")", c.ReadLine, f.isPortFree)
 	if newIMAPPort == "" {
 		newIMAPPort = currentPort
 	}
 	imapPortChanged := newIMAPPort != currentPort
 
-	currentPort = f.preferences.Get(preferences.SMTPPortKey)
+	currentPort = f.settings.Get(settings.SMTPPortKey)
 	newSMTPPort := f.readStringInAttempts("Set SMTP port (current "+currentPort+")", c.ReadLine, f.isPortFree)
 	if newSMTPPort == "" {
 		newSMTPPort = currentPort
@@ -118,10 +122,10 @@ func (f *frontendCLI) changePort(c *ishell.Context) {
 
 	if imapPortChanged || smtpPortChanged {
 		f.Println("Saving values IMAP:", newIMAPPort, "SMTP:", newSMTPPort)
-		f.preferences.Set(preferences.IMAPPortKey, newIMAPPort)
-		f.preferences.Set(preferences.SMTPPortKey, newSMTPPort)
+		f.settings.Set(settings.IMAPPortKey, newIMAPPort)
+		f.settings.Set(settings.SMTPPortKey, newSMTPPort)
 		f.Println("Restarting Bridge...")
-		f.appRestart = true
+		f.restarter.SetToRestart()
 		f.Stop()
 	} else {
 		f.Println("Nothing changed")
@@ -129,16 +133,16 @@ func (f *frontendCLI) changePort(c *ishell.Context) {
 }
 
 func (f *frontendCLI) toggleAllowProxy(c *ishell.Context) {
-	if f.preferences.GetBool(preferences.AllowProxyKey) {
+	if f.settings.GetBool(settings.AllowProxyKey) {
 		f.Println("Bridge is currently set to use alternative routing to connect to Proton if it is being blocked.")
 		if f.yesNoQuestion("Are you sure you want to stop bridge from doing this") {
-			f.preferences.SetBool(preferences.AllowProxyKey, false)
+			f.settings.SetBool(settings.AllowProxyKey, false)
 			f.bridge.DisallowProxy()
 		}
 	} else {
 		f.Println("Bridge is currently set to NOT use alternative routing to connect to Proton if it is being blocked.")
 		if f.yesNoQuestion("Are you sure you want to allow bridge to do this") {
-			f.preferences.SetBool(preferences.AllowProxyKey, true)
+			f.settings.SetBool(settings.AllowProxyKey, true)
 			f.bridge.AllowProxy()
 		}
 	}

internal/frontend/cli/updates.go

@@ -21,41 +21,15 @@ import (
 	"strings"
 
 	"github.com/ProtonMail/proton-bridge/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/internal/updates"
 	"github.com/abiosoft/ishell"
 )
 
 func (f *frontendCLI) checkUpdates(c *ishell.Context) {
-	isUpToDate, latestVersionInfo, err := f.updates.CheckIsUpToDate()
-	if err != nil {
-		f.printAndLogError("Cannot retrieve version info: ", err)
-		f.checkInternetConnection(c)
-		return
-	}
-	if isUpToDate {
-		f.Println("Your version is up to date.")
-	} else {
-		f.notifyNeedUpgrade()
-		f.Println("")
-		f.printReleaseNotes(latestVersionInfo)
-	}
+	f.Println("Your version is up to date.")
 }
 
 func (f *frontendCLI) printLocalReleaseNotes(c *ishell.Context) {
-	localVersion := f.updates.GetLocalVersion()
-	f.printReleaseNotes(localVersion)
-}
-
-func (f *frontendCLI) printReleaseNotes(versionInfo updates.VersionInfo) {
-	f.Println(bold("ProtonMail Bridge "+versionInfo.Version), "\n")
-	if versionInfo.ReleaseNotes != "" {
-		f.Println(bold("Release Notes"))
-		f.Println(versionInfo.ReleaseNotes)
-	}
-	if versionInfo.ReleaseFixedBugs != "" {
-		f.Println(bold("Fixed bugs"))
-		f.Println(versionInfo.ReleaseFixedBugs)
-	}
+	f.Println("TODO")
 }
 
 func (f *frontendCLI) printCredits(c *ishell.Context) {

internal/frontend/cli/utils.go

@@ -93,10 +93,10 @@ func (f *frontendCLI) notifyLogout(address string) {
 }
 
 func (f *frontendCLI) notifyNeedUpgrade() {
-	f.Println("Please download and install the newest version of application from", f.updates.GetDownloadLink())
+	f.Println("TODO")
 }
 
-func (f *frontendCLI) notifyCredentialsError() {
+func (f *frontendCLI) notifyCredentialsError() { // nolint[unused]
 	// Print in 80-column width.
 	f.Println("ProtonMail Bridge is not able to detect a supported password manager")
 	f.Println("(pass, gnome-keyring). Please install and set up a supported password manager")

internal/frontend/frontend.go

@@ -19,15 +19,16 @@
 package frontend
 
 import (
-	"github.com/0xAX/notificator"
 	"github.com/ProtonMail/proton-bridge/internal/bridge"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
 	"github.com/ProtonMail/proton-bridge/internal/frontend/cli"
 	cliie "github.com/ProtonMail/proton-bridge/internal/frontend/cli-ie"
 	"github.com/ProtonMail/proton-bridge/internal/frontend/qt"
 	qtie "github.com/ProtonMail/proton-bridge/internal/frontend/qt-ie"
 	"github.com/ProtonMail/proton-bridge/internal/frontend/types"
 	"github.com/ProtonMail/proton-bridge/internal/importexport"
-	"github.com/ProtonMail/proton-bridge/pkg/config"
+	"github.com/ProtonMail/proton-bridge/internal/locations"
+	"github.com/ProtonMail/proton-bridge/internal/updater"
 	"github.com/ProtonMail/proton-bridge/pkg/listener"
 	"github.com/sirupsen/logrus"
 )
@@ -38,17 +39,8 @@ var (
 
 // Frontend is an interface to be implemented by each frontend type (cli, gui, html).
 type Frontend interface {
-	Loop(credentialsError error) error
-	IsAppRestarting() bool
-}
-
-// HandlePanic handles panics which occur for users with GUI.
-func HandlePanic(appName string) {
-	notify := notificator.New(notificator.Options{
-		DefaultIcon: "../frontend/ui/icon/icon.png",
-		AppName:     appName,
-	})
-	_ = notify.Push("Fatal Error", "The "+appName+" has encountered a fatal error. ", "/frontend/icon/icon.png", notificator.UR_CRITICAL)
+	Loop() error
+	NotifyManualUpdate(update updater.VersionInfo) error
 }
 
 // New returns initialized frontend based on `frontendType`, which can be `cli` or `qt`.
@@ -58,35 +50,70 @@ func New(
 	frontendType string,
 	showWindowOnStart bool,
 	panicHandler types.PanicHandler,
-	config *config.Config,
-	preferences *config.Preferences,
+	locations *locations.Locations,
+	settings *settings.Settings,
 	eventListener listener.Listener,
-	updates types.Updater,
+	updater types.Updater,
 	bridge *bridge.Bridge,
 	noEncConfirmator types.NoEncConfirmator,
+	restarter types.Restarter,
 ) Frontend {
 	bridgeWrap := types.NewBridgeWrap(bridge)
-	return new(version, buildVersion, frontendType, showWindowOnStart, panicHandler, config, preferences, eventListener, updates, bridgeWrap, noEncConfirmator)
+	return newBridgeFrontend(
+		version,
+		buildVersion,
+		frontendType,
+		showWindowOnStart,
+		panicHandler,
+		locations,
+		settings,
+		eventListener,
+		updater,
+		bridgeWrap,
+		noEncConfirmator,
+		restarter,
+	)
 }
 
-func new(
+func newBridgeFrontend(
 	version,
 	buildVersion,
 	frontendType string,
 	showWindowOnStart bool,
 	panicHandler types.PanicHandler,
-	config *config.Config,
-	preferences *config.Preferences,
+	locations *locations.Locations,
+	settings *settings.Settings,
 	eventListener listener.Listener,
-	updates types.Updater,
+	updater types.Updater,
 	bridge types.Bridger,
 	noEncConfirmator types.NoEncConfirmator,
+	restarter types.Restarter,
 ) Frontend {
 	switch frontendType {
 	case "cli":
-		return cli.New(panicHandler, config, preferences, eventListener, updates, bridge)
+		return cli.New(
+			panicHandler,
+			locations,
+			settings,
+			eventListener,
+			updater,
+			bridge,
+			restarter,
+		)
 	default:
-		return qt.New(version, buildVersion, showWindowOnStart, panicHandler, config, preferences, eventListener, updates, bridge, noEncConfirmator)
+		return qt.New(
+			version,
+			buildVersion,
+			showWindowOnStart,
+			panicHandler,
+			locations,
+			settings,
+			eventListener,
+			updater,
+			bridge,
+			noEncConfirmator,
+			restarter,
+		)
 	}
 }
 
@@ -96,29 +123,43 @@ func NewImportExport(
 	buildVersion,
 	frontendType string,
 	panicHandler types.PanicHandler,
-	config *config.Config,
+
+	locations *locations.Locations,
 	eventListener listener.Listener,
-	updates types.Updater,
+	updater types.Updater,
 	ie *importexport.ImportExport,
+	restarter types.Restarter,
 ) Frontend {
 	ieWrap := types.NewImportExportWrap(ie)
-	return newImportExport(version, buildVersion, frontendType, panicHandler, config, eventListener, updates, ieWrap)
+	return newIEFrontend(
+		version,
+		buildVersion,
+		frontendType,
+		panicHandler,
+		locations,
+		eventListener,
+		updater,
+		ieWrap,
+		restarter,
+	)
 }
 
-func newImportExport(
+func newIEFrontend(
 	version,
 	buildVersion,
 	frontendType string,
 	panicHandler types.PanicHandler,
-	config *config.Config,
+
+	locations *locations.Locations,
 	eventListener listener.Listener,
-	updates types.Updater,
+	updater types.Updater,
 	ie types.ImportExporter,
+	restarter types.Restarter,
 ) Frontend {
 	switch frontendType {
 	case "cli":
-		return cliie.New(panicHandler, config, eventListener, updates, ie)
+		return cliie.New(panicHandler, locations, eventListener, updater, ie, restarter)
 	default:
-		return qtie.New(version, buildVersion, panicHandler, config, eventListener, updates, ie)
+		return qtie.New(version, buildVersion, panicHandler, locations, eventListener, updater, ie, restarter)
 	}
 }

internal/frontend/qml/BridgeUI/DialogPortChange.qml

@@ -226,7 +226,7 @@ Dialog {
         target: timer
         onTriggered: {
             go.setPortsAndSecurity(imapPort.text, smtpPort.text, securitySMTPSTARTTLS.checked)
-            go.isRestarting = true
+            go.setToRestart()
             Qt.quit()
         }
     }

internal/frontend/qml/GuiIE.qml

@@ -69,20 +69,9 @@ Item {
     Connections {
         target: go
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+        onShowWindow : {
+            winMain.showAndRise()
+        }
 
         onProcessFinished :  {
             winMain.dialogAddUser.hide()

internal/frontend/qml/tst_Gui.qml

@@ -566,7 +566,6 @@ Window {
             return 0
         }
 
-        property bool isRestarting: false
         function setPortsAndSecurity(portIMAP, portSMTP, secSMTP) {
             console.log("Test: ports changed", portIMAP, portSMTP, secSMTP)
         }

internal/frontend/qt-common/accounts.go

@@ -25,10 +25,9 @@ import (
 	"sync"
 
 	"github.com/ProtonMail/proton-bridge/internal/bridge"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
 	"github.com/ProtonMail/proton-bridge/internal/events"
 	"github.com/ProtonMail/proton-bridge/internal/frontend/types"
-	"github.com/ProtonMail/proton-bridge/internal/preferences"
-	"github.com/ProtonMail/proton-bridge/pkg/config"
 	"github.com/ProtonMail/proton-bridge/pkg/keychain"
 	"github.com/ProtonMail/proton-bridge/pkg/pmapi"
 )
@@ -38,7 +37,6 @@ type QMLer interface {
 	ProcessFinished()
 	NotifyHasNoKeychain()
 	SetConnectionStatus(bool)
-	SetIsRestarting(bool)
 	SetAddAccountWarning(string, int)
 	NotifyBubble(int, string)
 	EmitEvent(string, string)
@@ -50,23 +48,25 @@ type QMLer interface {
 
 // Accounts holds functionality of users
 type Accounts struct {
-	Model *AccountsModel
-	qml   QMLer
-	um    types.UserManager
-	prefs *config.Preferences
+	Model    *AccountsModel
+	qml      QMLer
+	um       types.UserManager
+	settings *settings.Settings
 
 	authClient pmapi.Client
 	auth       *pmapi.Auth
 
 	LatestUserID string
 	accountMutex sync.Mutex
+	restarter    types.Restarter
 }
 
 // SetupAccounts will create Model and set QMLer and UserManager
-func (a *Accounts) SetupAccounts(qml QMLer, um types.UserManager) {
+func (a *Accounts) SetupAccounts(qml QMLer, um types.UserManager, restarter types.Restarter) {
 	a.Model = NewAccountsModel(nil)
 	a.qml = qml
 	a.um = um
+	a.restarter = restarter
 }
 
 // LoadAccounts refreshes the current account list in GUI
@@ -102,9 +102,9 @@ func (a *Accounts) LoadAccounts() {
 		accInfo.SetUserID(user.ID())
 		accInfo.SetHostname(bridge.Host)
 		accInfo.SetPassword(user.GetBridgePassword())
-		if a.prefs != nil {
-			accInfo.SetPortIMAP(a.prefs.GetInt(preferences.IMAPPortKey))
-			accInfo.SetPortSMTP(a.prefs.GetInt(preferences.SMTPPortKey))
+		if a.settings != nil {
+			accInfo.SetPortIMAP(a.settings.GetInt(settings.IMAPPortKey))
+			accInfo.SetPortSMTP(a.settings.GetInt(settings.SMTPPortKey))
 		}
 
 		// Set aliases.
@@ -127,7 +127,7 @@ func (a *Accounts) ClearCache() {
 	}
 	// Clearing data removes everything (db, preferences, ...)
 	// so everything has to be stopped and started again.
-	a.qml.SetIsRestarting(true)
+	a.restarter.SetToRestart()
 	a.qml.Quit()
 }
 

internal/frontend/qt-common/common.go

@@ -111,10 +111,12 @@ func WaitForEnter() {
 
 type Listener interface {
 	Add(string, chan<- string)
+	RetryEmit(string)
 }
 
 func MakeAndRegisterEvent(eventListener Listener, event string) <-chan string {
 	ch := make(chan string)
 	eventListener.Add(event, ch)
+	eventListener.RetryEmit(event)
 	return ch
 }

internal/frontend/qt-ie/frontend.go

@@ -22,16 +22,14 @@ package qtie
 import (
 	"errors"
 	"os"
-	"strconv"
-	"time"
 
 	"github.com/ProtonMail/proton-bridge/internal/events"
 	qtcommon "github.com/ProtonMail/proton-bridge/internal/frontend/qt-common"
 	"github.com/ProtonMail/proton-bridge/internal/frontend/types"
 	"github.com/ProtonMail/proton-bridge/internal/importexport"
+	"github.com/ProtonMail/proton-bridge/internal/locations"
 	"github.com/ProtonMail/proton-bridge/internal/transfer"
-	"github.com/ProtonMail/proton-bridge/internal/updates"
-	"github.com/ProtonMail/proton-bridge/pkg/config"
+	"github.com/ProtonMail/proton-bridge/internal/updater"
 	"github.com/ProtonMail/proton-bridge/pkg/listener"
 
 	"github.com/therecipe/qt/core"
@@ -51,9 +49,9 @@ var log = logrus.WithField("pkg", "frontend-qt-ie")
 // Qt and QML objects. QML signals and slots are connected via methods of GoQMLInterface.
 type FrontendQt struct {
 	panicHandler  types.PanicHandler
-	config        *config.Config
+	locations     *locations.Locations
 	eventListener listener.Listener
-	updates       types.Updater
+	updater       types.Updater
 	ie            types.ImportExporter
 
 	App      *widgets.QApplication      // Main Application pointer
@@ -72,44 +70,39 @@ type FrontendQt struct {
 	transfer *transfer.Transfer
 	progress *transfer.Progress
 
-	notifyHasNoKeychain bool
+	restarter types.Restarter
 }
 
 // New is constructor for Import-Export Qt-Go interface
 func New(
 	version, buildVersion string,
 	panicHandler types.PanicHandler,
-	config *config.Config,
+
+	locations *locations.Locations,
 	eventListener listener.Listener,
-	updates types.Updater,
+	updater types.Updater,
 	ie types.ImportExporter,
+	restarter types.Restarter,
 ) *FrontendQt {
 	f := &FrontendQt{
 		panicHandler:   panicHandler,
-		config:         config,
+		locations:      locations,
 		programName:    "ProtonMail Import-Export",
 		programVersion: "v" + version,
 		eventListener:  eventListener,
+		updater:        updater,
 		buildVersion:   buildVersion,
-		updates:        updates,
 		ie:             ie,
+		restarter:      restarter,
 	}
 
 	log.Debugf("New Qt frontend: %p", f)
 	return f
 }
 
-// IsAppRestarting for Import-Export is always false i.e never restarts
-func (f *FrontendQt) IsAppRestarting() bool {
-	return false
-}
-
 // Loop function for Import-Export interface. It runs QtExecute in main thread
 // with no additional function.
-func (f *FrontendQt) Loop(setupError error) (err error) {
-	if setupError != nil {
-		f.notifyHasNoKeychain = true
-	}
+func (f *FrontendQt) Loop() (err error) {
 	go func() {
 		defer f.panicHandler.HandlePanic()
 		f.watchEvents()
@@ -118,9 +111,16 @@ func (f *FrontendQt) Loop(setupError error) (err error) {
 	return err
 }
 
+func (f *FrontendQt) NotifyManualUpdate(update updater.VersionInfo) error {
+	// NOTE: Save the update somewhere so that it can be installed when user chooses "install now".
+	return nil
+}
+
 func (f *FrontendQt) watchEvents() {
+	credentialsErrorCh := qtcommon.MakeAndRegisterEvent(f.eventListener, events.CredentialsErrorEvent)
 	internetOffCh := qtcommon.MakeAndRegisterEvent(f.eventListener, events.InternetOffEvent)
 	internetOnCh := qtcommon.MakeAndRegisterEvent(f.eventListener, events.InternetOnEvent)
+	secondInstanceCh := qtcommon.MakeAndRegisterEvent(f.eventListener, events.SecondInstanceEvent)
 	restartBridgeCh := qtcommon.MakeAndRegisterEvent(f.eventListener, events.RestartBridgeEvent)
 	addressChangedCh := qtcommon.MakeAndRegisterEvent(f.eventListener, events.AddressChangedEvent)
 	addressChangedLogoutCh := qtcommon.MakeAndRegisterEvent(f.eventListener, events.AddressChangedLogoutEvent)
@@ -129,12 +129,16 @@ func (f *FrontendQt) watchEvents() {
 	newUserCh := qtcommon.MakeAndRegisterEvent(f.eventListener, events.UserRefreshEvent)
 	for {
 		select {
+		case <-credentialsErrorCh:
+			f.Qml.NotifyHasNoKeychain()
 		case <-internetOffCh:
 			f.Qml.SetConnectionStatus(false)
 		case <-internetOnCh:
 			f.Qml.SetConnectionStatus(true)
+		case <-secondInstanceCh:
+			f.Qml.ShowWindow()
 		case <-restartBridgeCh:
-			f.Qml.SetIsRestarting(true)
+			f.restarter.SetToRestart()
 			f.App.Quit()
 		case address := <-addressChangedCh:
 			f.Qml.NotifyAddressChanged(address)
@@ -165,7 +169,7 @@ func (f *FrontendQt) qtSetupQmlAndStructures() {
 	f.View.RootContext().SetContextProperty("go", f.Qml)
 
 	// Add AccountsModel
-	f.Accounts.SetupAccounts(f.Qml, f.ie)
+	f.Accounts.SetupAccounts(f.Qml, f.ie, f.restarter)
 	f.View.RootContext().SetContextProperty("accountsModel", f.Accounts.Model)
 
 	// Add TransferRules structure
@@ -189,11 +193,6 @@ func (f *FrontendQt) qtSetupQmlAndStructures() {
 	} else {
 		f.Qml.SetIsFirstStart(false)
 	}
-
-	// Notify user about error during initialization.
-	if f.notifyHasNoKeychain {
-		f.Qml.NotifyHasNoKeychain()
-	}
 }
 
 // QtExecute in main for starting Qt application
@@ -233,7 +232,12 @@ func (f *FrontendQt) QtExecute(Procedure func(*FrontendQt) error) error {
 }
 
 func (f *FrontendQt) openLogs() {
-	go open.Run(f.config.GetLogDir())
+	logsPath, err := f.locations.ProvideLogsPath()
+	if err != nil {
+		return
+	}
+
+	go open.Run(logsPath)
 }
 
 func (f *FrontendQt) openReport() {
@@ -241,7 +245,7 @@ func (f *FrontendQt) openReport() {
 }
 
 func (f *FrontendQt) openDownloadLink() {
-	go open.Run(f.updates.GetDownloadLink())
+	// NOTE: Fix this.
 }
 
 // sendImportReport sends an anonymized import or export report file to our customer support
@@ -365,34 +369,8 @@ func (f *FrontendQt) setProgressManager(progress *transfer.Progress) {
 	}()
 }
 
-// StartUpdate is identical to bridge
 func (f *FrontendQt) StartUpdate() {
-	progress := make(chan updates.Progress)
-	go func() { // Update progress in QML.
-		defer f.panicHandler.HandlePanic()
-		for current := range progress {
-			f.Qml.SetProgress(current.Processed)
-			f.Qml.SetProgressDescription(strconv.Itoa(current.Description))
-			// Error happend
-			if current.Err != nil {
-				log.Error("update progress: ", current.Err)
-				f.Qml.UpdateFinished(true)
-				return
-			}
-			// Finished everything OK.
-			if current.Description >= updates.InfoQuitApp {
-				f.Qml.UpdateFinished(false)
-				time.Sleep(3 * time.Second) // Just notify.
-				f.Qml.SetIsRestarting(current.Description == updates.InfoRestartApp)
-				f.App.Quit()
-				return
-			}
-		}
-	}()
-	go func() {
-		defer f.panicHandler.HandlePanic()
-		f.updates.StartUpgrade(progress)
-	}()
+	// NOTE: Fix this.
 }
 
 // isNewVersionAvailable is identical to bridge
@@ -401,26 +379,11 @@ func (f *FrontendQt) StartUpdate() {
 func (f *FrontendQt) isNewVersionAvailable(showMessage bool) {
 	go func() {
 		defer f.Qml.ProcessFinished()
-		isUpToDate, latestVersionInfo, err := f.updates.CheckIsUpToDate()
-		if err != nil {
-			log.Warnln("Cannot retrieve version info: ", err)
-			f.checkInternet()
-			return
-		}
 		f.Qml.SetConnectionStatus(true) // if we are here connection is ok
-		if isUpToDate {
-			f.Qml.SetUpdateState(StatusUpToDate)
-			if showMessage {
-				f.Qml.NotifyVersionIsTheLatest()
-			}
-			return
+		f.Qml.SetUpdateState(StatusUpToDate)
+		if showMessage {
+			f.Qml.NotifyVersionIsTheLatest()
 		}
-		f.Qml.SetNewversion(latestVersionInfo.Version)
-		f.Qml.SetChangelog(latestVersionInfo.ReleaseNotes)
-		f.Qml.SetBugfixes(latestVersionInfo.ReleaseFixedBugs)
-		f.Qml.SetLandingPage(latestVersionInfo.LandingPage)
-		f.Qml.SetDownloadLink(latestVersionInfo.GetDownloadLink())
-		f.Qml.SetUpdateState(StatusNewVersionAvailable)
 	}()
 }
 
@@ -434,16 +397,12 @@ func (f *FrontendQt) resetSource() {
 }
 
 func (f *FrontendQt) openLicenseFile() {
-	go open.Run(f.config.GetLicenseFilePath())
+	go open.Run(f.locations.GetLicenseFilePath())
 }
 
 // getLocalVersionInfo is identical to bridge.
 func (f *FrontendQt) getLocalVersionInfo() {
-	defer f.Qml.ProcessFinished()
-	localVersion := f.updates.GetLocalVersion()
-	f.Qml.SetNewversion(localVersion.Version)
-	f.Qml.SetChangelog(localVersion.ReleaseNotes)
-	f.Qml.SetBugfixes(localVersion.ReleaseFixedBugs)
+	// NOTE: Fix this.
 }
 
 // LeastUsedColor is intended to return color for creating a new inbox or label.

internal/frontend/qt-ie/frontend_nogui.go

@@ -24,7 +24,8 @@ import (
 	"net/http"
 
 	"github.com/ProtonMail/proton-bridge/internal/frontend/types"
-	"github.com/ProtonMail/proton-bridge/pkg/config"
+	"github.com/ProtonMail/proton-bridge/internal/locations"
+	"github.com/ProtonMail/proton-bridge/internal/updater"
 	"github.com/ProtonMail/proton-bridge/pkg/listener"
 	"github.com/sirupsen/logrus"
 )
@@ -33,23 +34,27 @@ var log = logrus.WithField("pkg", "frontend-nogui") //nolint[gochecknoglobals]
 
 type FrontendHeadless struct{}
 
-func (s *FrontendHeadless) Loop(credentialsError error) error {
-	log.Info("Check status on localhost:8081")
+func (s *FrontendHeadless) Loop() error {
+	log.Info("Check status on localhost:8082")
 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		fmt.Fprintf(w, "IE is running")
 	})
-	return http.ListenAndServe(":8081", nil)
+	return http.ListenAndServe(":8082", nil)
 }
 
-func (s *FrontendHeadless) IsAppRestarting() bool { return false }
+func (s *FrontendHeadless) NotifyManualUpdate(update updater.VersionInfo) error {
+	// NOTE: Save the update somewhere so that it can be installed when user chooses "install now".
+	return nil
+}
 
 func New(
 	version, buildVersion string,
 	panicHandler types.PanicHandler,
-	config *config.Config,
+	locations *locations.Locations,
 	eventListener listener.Listener,
-	updates types.Updater,
+	updater types.Updater,
 	ie types.ImportExporter,
+	restarter types.Restarter,
 ) *FrontendHeadless {
 	return &FrontendHeadless{}
 }

internal/frontend/qt-ie/ui.go

@@ -37,7 +37,6 @@ type GoQMLInterface struct {
 	_ string `property:"goos"`
 	_ string `property:"credits"`
 	_ bool   `property:"isFirstStart"`
-	_ bool   `property:"isRestarting"`
 	_ bool   `property:"isConnectionOK"`
 
 	_ string  `property:lastError`
@@ -68,6 +67,8 @@ type GoQMLInterface struct {
 	_ func(updateState string) `signal:"setUpdateState"`
 	_ func()                   `slot:"checkInternet"`
 
+	_ func() `slot:"setToRestart"`
+
 	_ func()                 `signal:"processFinished"`
 	_ func(okay bool)        `signal:"exportStructureLoadFinished"`
 	_ func(okay bool)        `signal:"importStructuresLoadFinished"`
@@ -77,6 +78,8 @@ type GoQMLInterface struct {
 	_ func()                 `slot:"getLocalVersionInfo"`
 	_ func()                 `slot:"loadImportReports"`
 
+	_ func() `signal:"showWindow"`
+
 	_ func() `slot:"quit"`
 	_ func() `slot:"loadAccounts"`
 	_ func() `slot:"openLogs"`
@@ -165,7 +168,6 @@ func (s *GoQMLInterface) SetFrontend(f *FrontendQt) {
 	s.ConnectAddAccount(f.Accounts.AddAccount)
 
 	s.SetGoos(runtime.GOOS)
-	s.SetIsRestarting(false)
 	s.SetProgramTitle(f.programName)
 
 	s.ConnectOpenLicenseFile(f.openLicenseFile)
@@ -177,6 +179,8 @@ func (s *GoQMLInterface) SetFrontend(f *FrontendQt) {
 
 	s.ConnectCheckInternet(f.checkInternet)
 
+	s.ConnectSetToRestart(f.restarter.SetToRestart)
+
 	s.ConnectLoadStructureForExport(f.LoadStructureForExport)
 	s.ConnectSetupAndLoadForImport(f.setupAndLoadForImport)
 	s.ConnectResetSource(f.resetSource)

internal/frontend/qt/accounts.go

@@ -24,8 +24,8 @@ import (
 	"strings"
 
 	"github.com/ProtonMail/proton-bridge/internal/bridge"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
 	"github.com/ProtonMail/proton-bridge/internal/events"
-	"github.com/ProtonMail/proton-bridge/internal/preferences"
 	"github.com/ProtonMail/proton-bridge/pkg/keychain"
 	pmapi "github.com/ProtonMail/proton-bridge/pkg/pmapi"
 )
@@ -63,8 +63,8 @@ func (s *FrontendQt) loadAccounts() {
 		acc_info.SetUserID(user.ID())
 		acc_info.SetHostname(bridge.Host)
 		acc_info.SetPassword(user.GetBridgePassword())
-		acc_info.SetPortIMAP(s.preferences.GetInt(preferences.IMAPPortKey))
-		acc_info.SetPortSMTP(s.preferences.GetInt(preferences.SMTPPortKey))
+		acc_info.SetPortIMAP(s.settings.GetInt(settings.IMAPPortKey))
+		acc_info.SetPortSMTP(s.settings.GetInt(settings.SMTPPortKey))
 
 		// Set aliases.
 		acc_info.SetAliases(strings.Join(user.GetAddresses(), ";"))
@@ -85,7 +85,7 @@ func (s *FrontendQt) clearCache() {
 	}
 	// Clearing data removes everything (db, preferences, ...)
 	// so everything has to be stopped and started again.
-	s.Qml.SetIsRestarting(true)
+	s.restarter.SetToRestart()
 	s.App.Quit()
 }
 

internal/frontend/qt/frontend.go

@@ -38,13 +38,13 @@ import (
 
 	"github.com/ProtonMail/go-autostart"
 	"github.com/ProtonMail/proton-bridge/internal/bridge"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
 	"github.com/ProtonMail/proton-bridge/internal/events"
 	"github.com/ProtonMail/proton-bridge/internal/frontend/autoconfig"
 	qtcommon "github.com/ProtonMail/proton-bridge/internal/frontend/qt-common"
 	"github.com/ProtonMail/proton-bridge/internal/frontend/types"
-	"github.com/ProtonMail/proton-bridge/internal/preferences"
-	"github.com/ProtonMail/proton-bridge/internal/updates"
-	"github.com/ProtonMail/proton-bridge/pkg/config"
+	"github.com/ProtonMail/proton-bridge/internal/locations"
+	"github.com/ProtonMail/proton-bridge/internal/updater"
 	"github.com/ProtonMail/proton-bridge/pkg/listener"
 	"github.com/ProtonMail/proton-bridge/pkg/pmapi"
 	"github.com/ProtonMail/proton-bridge/pkg/ports"
@@ -70,10 +70,10 @@ type FrontendQt struct {
 	buildVersion      string
 	showWindowOnStart bool
 	panicHandler      types.PanicHandler
-	config            *config.Config
-	preferences       *config.Preferences
+	locations         *locations.Locations
+	settings          *settings.Settings
 	eventListener     listener.Listener
-	updates           types.Updater
+	updater           types.Updater
 	bridge            types.Bridger
 	noEncConfirmator  types.NoEncConfirmator
 
@@ -94,21 +94,22 @@ type FrontendQt struct {
 	// expand userID when added
 	userIDAdded string
 
-	notifyHasNoKeychain bool
+	restarter types.Restarter
 }
 
-// New returns a new Qt frontendend for the bridge.
+// New returns a new Qt frontend for the bridge.
 func New(
 	version,
 	buildVersion string,
 	showWindowOnStart bool,
 	panicHandler types.PanicHandler,
-	config *config.Config,
-	preferences *config.Preferences,
+	locations *locations.Locations,
+	settings *settings.Settings,
 	eventListener listener.Listener,
-	updates types.Updater,
+	updater types.Updater,
 	bridge types.Bridger,
 	noEncConfirmator types.NoEncConfirmator,
+	restarter types.Restarter,
 ) *FrontendQt {
 	prgName := "ProtonMail Bridge"
 	tmp := &FrontendQt{
@@ -116,10 +117,10 @@ func New(
 		buildVersion:      buildVersion,
 		showWindowOnStart: showWindowOnStart,
 		panicHandler:      panicHandler,
-		config:            config,
-		preferences:       preferences,
+		locations:         locations,
+		settings:          settings,
 		eventListener:     eventListener,
-		updates:           updates,
+		updater:           updater,
 		bridge:            bridge,
 		noEncConfirmator:  noEncConfirmator,
 
@@ -130,6 +131,8 @@ func New(
 			DisplayName: prgName,
 			Exec:        []string{"", "--no-window"},
 		},
+
+		restarter: restarter,
 	}
 
 	// Handle autostart if wanted.
@@ -161,10 +164,7 @@ func (s *FrontendQt) InstanceExistAlert() {
 // Loop function for Bridge interface.
 //
 // It runs QtExecute in main thread with no additional function.
-func (s *FrontendQt) Loop(credentialsError error) (err error) {
-	if credentialsError != nil {
-		s.notifyHasNoKeychain = true
-	}
+func (s *FrontendQt) Loop() (err error) {
 	go func() {
 		defer s.panicHandler.HandlePanic()
 		s.watchEvents()
@@ -173,8 +173,14 @@ func (s *FrontendQt) Loop(credentialsError error) (err error) {
 	return err
 }
 
+func (s *FrontendQt) NotifyManualUpdate(update updater.VersionInfo) error {
+	// NOTE: Save the update somewhere so that it can be installed when user chooses "install now".
+	return nil
+}
+
 func (s *FrontendQt) watchEvents() {
 	errorCh := s.getEventChannel(events.ErrorEvent)
+	credentialsErrorCh := s.getEventChannel(events.CredentialsErrorEvent)
 	outgoingNoEncCh := s.getEventChannel(events.OutgoingNoEncEvent)
 	noActiveKeyForRecipientCh := s.getEventChannel(events.NoActiveKeyForRecipientEvent)
 	internetOffCh := s.getEventChannel(events.InternetOffEvent)
@@ -193,6 +199,8 @@ func (s *FrontendQt) watchEvents() {
 			imapIssue := strings.Contains(errorDetails, "IMAP failed")
 			smtpIssue := strings.Contains(errorDetails, "SMTP failed")
 			s.Qml.NotifyPortIssue(imapIssue, smtpIssue)
+		case <-credentialsErrorCh:
+			s.Qml.NotifyHasNoKeychain()
 		case idAndSubject := <-outgoingNoEncCh:
 			idAndSubjectSlice := strings.SplitN(idAndSubject, ":", 2)
 			messageID := idAndSubjectSlice[0]
@@ -207,7 +215,7 @@ func (s *FrontendQt) watchEvents() {
 		case <-secondInstanceCh:
 			s.Qml.ShowWindow()
 		case <-restartBridgeCh:
-			s.Qml.SetIsRestarting(true)
+			s.restarter.SetToRestart()
 			// watchEvents is started in parallel with the Qt app.
 			// If the event comes too early, app might not be ready yet.
 			if s.App != nil {
@@ -267,10 +275,6 @@ func (s *FrontendQt) Start() (err error) {
 	return nil
 }
 
-func (s *FrontendQt) IsAppRestarting() bool {
-	return s.Qml.IsRestarting()
-}
-
 // InvMethod runs the function with name `method` defined in RootObject of the QML.
 // Used for tests.
 func (s *FrontendQt) InvMethod(method string) error {
@@ -304,13 +308,13 @@ func (s *FrontendQt) qtExecute(Procedure func(*FrontendQt) error) error {
 	s.View.RootContext().SetContextProperty("go", s.Qml)
 
 	// Set first start flag.
-	s.Qml.SetIsFirstStart(s.preferences.GetBool(preferences.FirstStartGUIKey))
-	s.preferences.SetBool(preferences.FirstStartGUIKey, false)
+	s.Qml.SetIsFirstStart(s.settings.GetBool(settings.FirstStartGUIKey))
+	s.settings.SetBool(settings.FirstStartGUIKey, false)
 
 	// Check if it is first start after update (fresh version).
-	lastVersion := s.preferences.Get(preferences.LastVersionKey)
+	lastVersion := s.settings.Get(settings.LastVersionKey)
 	s.Qml.SetIsFreshVersion(lastVersion != "" && s.version != lastVersion)
-	s.preferences.Set(preferences.LastVersionKey, s.version)
+	s.settings.Set(settings.LastVersionKey, s.version)
 
 	// Add AccountsModel.
 	s.Accounts = NewAccountsModel(nil)
@@ -339,27 +343,25 @@ func (s *FrontendQt) qtExecute(Procedure func(*FrontendQt) error) error {
 		s.Qml.SetIsAutoStart(false)
 	}
 
-	if s.preferences.GetBool(preferences.AllowProxyKey) {
+	if s.settings.GetBool(settings.AllowProxyKey) {
 		s.Qml.SetIsProxyAllowed(true)
 	} else {
 		s.Qml.SetIsProxyAllowed(false)
 	}
 
-	// Notify user about error during initialization.
-	if s.notifyHasNoKeychain {
-		s.Qml.NotifyHasNoKeychain()
-	}
-
 	s.eventListener.RetryEmit(events.TLSCertIssue)
 	s.eventListener.RetryEmit(events.ErrorEvent)
 
 	// Set reporting of outgoing email without encryption.
-	s.Qml.SetIsReportingOutgoingNoEnc(s.preferences.GetBool(preferences.ReportOutgoingNoEncKey))
+	s.Qml.SetIsReportingOutgoingNoEnc(s.settings.GetBool(settings.ReportOutgoingNoEncKey))
+
+	defaultIMAPPort, _ := strconv.Atoi(settings.DefaultIMAPPort)
+	defaultSMTPPort, _ := strconv.Atoi(settings.DefaultSMTPPort)
 
 	// IMAP/SMTP ports.
 	s.Qml.SetIsDefaultPort(
-		s.config.GetDefaultIMAPPort() == s.preferences.GetInt(preferences.IMAPPortKey) &&
-			s.config.GetDefaultSMTPPort() == s.preferences.GetInt(preferences.SMTPPortKey),
+		defaultIMAPPort == s.settings.GetInt(settings.IMAPPortKey) &&
+			defaultSMTPPort == s.settings.GetInt(settings.SMTPPortKey),
 	)
 
 	// Check QML is loaded properly.
@@ -387,7 +389,12 @@ func (s *FrontendQt) qtExecute(Procedure func(*FrontendQt) error) error {
 }
 
 func (s *FrontendQt) openLogs() {
-	go open.Run(s.config.GetLogDir())
+	logsPath, err := s.locations.ProvideLogsPath()
+	if err != nil {
+		return
+	}
+
+	go open.Run(logsPath)
 }
 
 // Check version in separate goroutine to not block the GUI (avoid program not responding message).
@@ -395,40 +402,20 @@ func (s *FrontendQt) isNewVersionAvailable(showMessage bool) {
 	go func() {
 		defer s.panicHandler.HandlePanic()
 		defer s.Qml.ProcessFinished()
-		isUpToDate, latestVersionInfo, err := s.updates.CheckIsUpToDate()
-		if err != nil {
-			log.Warn("Can not retrieve version info: ", err)
-			s.checkInternet()
-			return
-		}
 		s.Qml.SetConnectionStatus(true) // If we are here connection is ok.
-		if isUpToDate {
-			s.Qml.SetUpdateState("upToDate")
-			if showMessage {
-				s.Qml.NotifyVersionIsTheLatest()
-			}
-			return
+		s.Qml.SetUpdateState("upToDate")
+		if showMessage {
+			s.Qml.NotifyVersionIsTheLatest()
 		}
-		s.Qml.SetNewversion(latestVersionInfo.Version)
-		s.Qml.SetChangelog(latestVersionInfo.ReleaseNotes)
-		s.Qml.SetBugfixes(latestVersionInfo.ReleaseFixedBugs)
-		s.Qml.SetLandingPage(latestVersionInfo.LandingPage)
-		s.Qml.SetDownloadLink(latestVersionInfo.GetDownloadLink())
-		s.Qml.ShowWindow()
-		s.Qml.SetUpdateState("oldVersion")
 	}()
 }
 
 func (s *FrontendQt) openLicenseFile() {
-	go open.Run(s.config.GetLicenseFilePath())
+	go open.Run(s.locations.GetLicenseFilePath())
 }
 
 func (s *FrontendQt) getLocalVersionInfo() {
-	defer s.Qml.ProcessFinished()
-	localVersion := s.updates.GetLocalVersion()
-	s.Qml.SetNewversion(localVersion.Version)
-	s.Qml.SetChangelog(localVersion.ReleaseNotes)
-	s.Qml.SetBugfixes(localVersion.ReleaseFixedBugs)
+	// NOTE: Fix this.
 }
 
 func (s *FrontendQt) sendBug(description, client, address string) (isOK bool) {
@@ -465,16 +452,16 @@ func (s *FrontendQt) configureAppleMail(iAccount, iAddress int) {
 		return
 	}
 
-	imapPort := s.preferences.GetInt(preferences.IMAPPortKey)
+	imapPort := s.settings.GetInt(settings.IMAPPortKey)
 	imapSSL := false
-	smtpPort := s.preferences.GetInt(preferences.SMTPPortKey)
-	smtpSSL := s.preferences.GetBool(preferences.SMTPSSLKey)
+	smtpPort := s.settings.GetInt(settings.SMTPPortKey)
+	smtpSSL := s.settings.GetBool(settings.SMTPSSLKey)
 
 	// If configuring apple mail for Catalina or newer, users should use SSL.
 	doRestart := false
 	if !smtpSSL && useragent.IsCatalinaOrNewer() {
 		smtpSSL = true
-		s.preferences.SetBool(preferences.SMTPSSLKey, true)
+		s.settings.SetBool(settings.SMTPSSLKey, true)
 		log.Warn("Detected Catalina or newer with bad SMTP SSL settings, now using SSL, bridge needs to restart")
 		doRestart = true
 	}
@@ -489,7 +476,7 @@ func (s *FrontendQt) configureAppleMail(iAccount, iAddress int) {
 
 	if doRestart {
 		time.Sleep(2 * time.Second)
-		s.Qml.SetIsRestarting(true)
+		s.restarter.SetToRestart()
 		s.App.Quit()
 	}
 	return
@@ -517,23 +504,23 @@ func (s *FrontendQt) toggleAutoStart() {
 func (s *FrontendQt) toggleAllowProxy() {
 	defer s.Qml.ProcessFinished()
 
-	if s.preferences.GetBool(preferences.AllowProxyKey) {
-		s.preferences.SetBool(preferences.AllowProxyKey, false)
+	if s.settings.GetBool(settings.AllowProxyKey) {
+		s.settings.SetBool(settings.AllowProxyKey, false)
 		s.bridge.DisallowProxy()
 		s.Qml.SetIsProxyAllowed(false)
 	} else {
-		s.preferences.SetBool(preferences.AllowProxyKey, true)
+		s.settings.SetBool(settings.AllowProxyKey, true)
 		s.bridge.AllowProxy()
 		s.Qml.SetIsProxyAllowed(true)
 	}
 }
 
 func (s *FrontendQt) getIMAPPort() string {
-	return s.preferences.Get(preferences.IMAPPortKey)
+	return s.settings.Get(settings.IMAPPortKey)
 }
 
 func (s *FrontendQt) getSMTPPort() string {
-	return s.preferences.Get(preferences.SMTPPortKey)
+	return s.settings.Get(settings.SMTPPortKey)
 }
 
 // Return 0 -- port is free to use for server.
@@ -550,13 +537,13 @@ func (s *FrontendQt) isPortOpen(portStr string) int {
 }
 
 func (s *FrontendQt) setPortsAndSecurity(imapPort, smtpPort string, useSTARTTLSforSMTP bool) {
-	s.preferences.Set(preferences.IMAPPortKey, imapPort)
-	s.preferences.Set(preferences.SMTPPortKey, smtpPort)
-	s.preferences.SetBool(preferences.SMTPSSLKey, !useSTARTTLSforSMTP)
+	s.settings.Set(settings.IMAPPortKey, imapPort)
+	s.settings.Set(settings.SMTPPortKey, smtpPort)
+	s.settings.SetBool(settings.SMTPSSLKey, !useSTARTTLSforSMTP)
 }
 
 func (s *FrontendQt) isSMTPSTARTTLS() bool {
-	return !s.preferences.GetBool(preferences.SMTPSSLKey)
+	return !s.settings.GetBool(settings.SMTPSSLKey)
 }
 
 func (s *FrontendQt) checkInternet() {
@@ -594,7 +581,7 @@ func (s *FrontendQt) autostartError(err error) {
 
 func (s *FrontendQt) toggleIsReportingOutgoingNoEnc() {
 	shouldReport := !s.Qml.IsReportingOutgoingNoEnc()
-	s.preferences.SetBool(preferences.ReportOutgoingNoEncKey, shouldReport)
+	s.settings.SetBool(settings.ReportOutgoingNoEncKey, shouldReport)
 	s.Qml.SetIsReportingOutgoingNoEnc(shouldReport)
 }
 
@@ -608,30 +595,5 @@ func (s *FrontendQt) saveOutgoingNoEncPopupCoord(x, y float32) {
 }
 
 func (s *FrontendQt) StartUpdate() {
-	progress := make(chan updates.Progress)
-	go func() { // Update progress in QML.
-		defer s.panicHandler.HandlePanic()
-		for current := range progress {
-			s.Qml.SetProgress(current.Processed)
-			s.Qml.SetProgressDescription(strconv.Itoa(current.Description))
-			// Error happend
-			if current.Err != nil {
-				log.Error("update progress: ", current.Err)
-				s.Qml.UpdateFinished(true)
-				return
-			}
-			// Finished everything OK.
-			if current.Description >= updates.InfoQuitApp {
-				s.Qml.UpdateFinished(false)
-				time.Sleep(3 * time.Second) // Just notify.
-				s.Qml.SetIsRestarting(current.Description == updates.InfoRestartApp)
-				s.App.Quit()
-				return
-			}
-		}
-	}()
-	go func() {
-		defer s.panicHandler.HandlePanic()
-		s.updates.StartUpgrade(progress)
-	}()
+	// NOTE: Fix this.
 }

internal/frontend/qt/frontend_nogui.go

@@ -23,8 +23,10 @@ import (
 	"fmt"
 	"net/http"
 
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
 	"github.com/ProtonMail/proton-bridge/internal/frontend/types"
-	"github.com/ProtonMail/proton-bridge/pkg/config"
+	"github.com/ProtonMail/proton-bridge/internal/locations"
+	"github.com/ProtonMail/proton-bridge/internal/updater"
 	"github.com/ProtonMail/proton-bridge/pkg/listener"
 	"github.com/sirupsen/logrus"
 )
@@ -33,7 +35,7 @@ var log = logrus.WithField("pkg", "frontend-nogui") //nolint[gochecknoglobals]
 
 type FrontendHeadless struct{}
 
-func (s *FrontendHeadless) Loop(credentialsError error) error {
+func (s *FrontendHeadless) Loop() error {
 	log.Info("Check status on localhost:8081")
 	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		fmt.Fprintf(w, "Bridge is running")
@@ -41,20 +43,25 @@ func (s *FrontendHeadless) Loop(credentialsError error) error {
 	return http.ListenAndServe(":8081", nil)
 }
 
-func (s *FrontendHeadless) InstanceExistAlert()   {}
-func (s *FrontendHeadless) IsAppRestarting() bool { return false }
+func (s *FrontendHeadless) NotifyManualUpdate(update updater.VersionInfo) error {
+	// NOTE: Save the update somewhere so that it can be installed when user chooses "install now".
+	return nil
+}
+
+func (s *FrontendHeadless) InstanceExistAlert() {}
 
 func New(
 	version,
 	buildVersion string,
 	showWindowOnStart bool,
 	panicHandler types.PanicHandler,
-	config *config.Config,
-	preferences *config.Preferences,
+	locations *locations.Locations,
+	settings *settings.Settings,
 	eventListener listener.Listener,
-	updates types.Updater,
+	updater types.Updater,
 	bridge types.Bridger,
 	noEncConfirmator types.NoEncConfirmator,
+	restarter types.Restarter,
 ) *FrontendHeadless {
 	return &FrontendHeadless{}
 }

internal/frontend/qt/ui.go

@@ -41,7 +41,6 @@ type GoQMLInterface struct {
 	_ bool   `property:"isShownOnStart"`
 	_ bool   `property:"isFirstStart"`
 	_ bool   `property:"isFreshVersion"`
-	_ bool   `property:"isRestarting"`
 	_ bool   `property:"isConnectionOK"`
 	_ bool   `property:"isDefaultPort"`
 
@@ -70,6 +69,8 @@ type GoQMLInterface struct {
 	_ func(updateState string) `signal:"setUpdateState"`
 	_ func()                   `slot:"checkInternet"`
 
+	_ func() `slot:"setToRestart"`
+
 	_ func(systX, systY, systW, systH int) `signal:"toggleMainWin"`
 
 	_ func()                 `signal:"processFinished"`
@@ -178,7 +179,6 @@ func (s *GoQMLInterface) SetFrontend(f *FrontendQt) {
 	s.ConnectSwitchAddressMode(f.switchAddressModeUser)
 
 	s.SetGoos(runtime.GOOS)
-	s.SetIsRestarting(false)
 	s.SetProgramTitle(f.programName)
 
 	s.ConnectGetBackendVersion(func() string {
@@ -187,6 +187,8 @@ func (s *GoQMLInterface) SetFrontend(f *FrontendQt) {
 
 	s.ConnectCheckInternet(f.checkInternet)
 
+	s.ConnectSetToRestart(f.restarter.SetToRestart)
+
 	s.ConnectToggleIsReportingOutgoingNoEnc(f.toggleIsReportingOutgoingNoEnc)
 	s.ConnectShouldSendAnswer(f.shouldSendAnswer)
 	s.ConnectSaveOutgoingNoEncPopupCoord(f.saveOutgoingNoEncPopupCoord)

internal/frontend/types/types.go

@@ -22,7 +22,7 @@ import (
 	"github.com/ProtonMail/proton-bridge/internal/bridge"
 	"github.com/ProtonMail/proton-bridge/internal/importexport"
 	"github.com/ProtonMail/proton-bridge/internal/transfer"
-	"github.com/ProtonMail/proton-bridge/internal/updates"
+	"github.com/ProtonMail/proton-bridge/internal/updater"
 	"github.com/ProtonMail/proton-bridge/pkg/pmapi"
 )
 
@@ -31,18 +31,19 @@ type PanicHandler interface {
 	HandlePanic()
 }
 
-// Updater is an interface for handling Bridge upgrades.
-type Updater interface {
-	CheckIsUpToDate() (isUpToDate bool, latestVersion updates.VersionInfo, err error)
-	GetDownloadLink() string
-	GetLocalVersion() updates.VersionInfo
-	StartUpgrade(currentStatus chan<- updates.Progress)
+// Restarter allows the app to set itself to restart next time it is closed.
+type Restarter interface {
+	SetToRestart()
 }
 
 type NoEncConfirmator interface {
 	ConfirmNoEncryption(string, bool)
 }
 
+type Updater interface {
+	InstallUpdate(updater.VersionInfo) error
+}
+
 // UserManager is an interface of users needed by frontend.
 type UserManager interface {
 	Login(username, password string) (pmapi.Client, *pmapi.Auth, error)

internal/imap/backend.go

@@ -55,11 +55,11 @@ type imapBackend struct {
 func NewIMAPBackend(
 	panicHandler panicHandler,
 	eventListener listener.Listener,
-	cfg configProvider,
+	cache cacheProvider,
 	bridge *bridge.Bridge,
 ) *imapBackend { //nolint[golint]
 	bridgeWrap := newBridgeWrap(bridge)
-	backend := newIMAPBackend(panicHandler, cfg, bridgeWrap, eventListener)
+	backend := newIMAPBackend(panicHandler, cache, bridgeWrap, eventListener)
 
 	go backend.monitorDisconnectedUsers()
 
@@ -68,7 +68,7 @@ func NewIMAPBackend(
 
 func newIMAPBackend(
 	panicHandler panicHandler,
-	cfg configProvider,
+	cache cacheProvider,
 	bridge bridger,
 	eventListener listener.Listener,
 ) *imapBackend {
@@ -81,7 +81,7 @@ func newIMAPBackend(
 		users:       map[string]*imapUser{},
 		usersLocker: &sync.Mutex{},
 
-		imapCachePath: cfg.GetIMAPCachePath(),
+		imapCachePath: cache.GetIMAPCachePath(),
 		imapCacheLock: &sync.RWMutex{},
 
 		updatesBlocking:       map[string]bool{},

internal/imap/bridge.go

@@ -23,8 +23,7 @@ import (
 	"github.com/ProtonMail/proton-bridge/pkg/pmapi"
 )
 
-type configProvider interface {
-	GetEventsPath() string
+type cacheProvider interface {
 	GetDBDir() string
 	GetIMAPCachePath() string
 }

internal/imap/server.go

@@ -58,6 +58,13 @@ func NewIMAPServer(debugClient, debugServer bool, port int, tls *tls.Config, ima
 	s.ErrorLog = newServerErrorLogger("server-imap")
 	s.AutoLogout = 30 * time.Minute
 
+	if debugServer {
+		fmt.Println("THE LOG WILL CONTAIN **DECRYPTED** MESSAGE DATA")
+		log.Warning("================================================")
+		log.Warning("THIS LOG WILL CONTAIN **DECRYPTED** MESSAGE DATA")
+		log.Warning("================================================")
+	}
+
 	serverID := imapid.ID{
 		imapid.FieldName:       "ProtonMail Bridge",
 		imapid.FieldVendor:     "Proton Technologies AG",

internal/importexport/credits.go

@@ -15,8 +15,8 @@
 // You should have received a copy of the GNU General Public License
 // along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
 
-// Code generated by ./credits.sh at Mon Dec 28 02:39:43 PM CET 2020. DO NOT EDIT.
+// Code generated by ./credits.sh at Mon Jan 4 03:19:07 PM CET 2021. DO NOT EDIT.
 
 package importexport
 
-const Credits = "github.com/0xAX/notificator;github.com/abiosoft/ishell;github.com/abiosoft/readline;github.com/allan-simon/go-singleinstance;github.com/chzyer/logex;github.com/chzyer/test;github.com/cucumber/godog;github.com/docker/docker-credential-helpers;github.com/emersion/go-imap;github.com/emersion/go-imap-appendlimit;github.com/emersion/go-imap-idle;github.com/emersion/go-imap-move;github.com/emersion/go-imap-quota;github.com/emersion/go-imap-unselect;github.com/emersion/go-mbox;github.com/emersion/go-message;github.com/emersion/go-sasl;github.com/emersion/go-smtp;github.com/emersion/go-textwrapper;github.com/emersion/go-vcard;github.com/fatih/color;github.com/flynn-archive/go-shlex;github.com/getsentry/sentry-go;github.com/golang/mock;github.com/google/go-cmp;github.com/google/uuid;github.com/gopherjs/gopherjs;github.com/go-resty/resty/v2;github.com/hashicorp/go-multierror;github.com/jameskeane/bcrypt;github.com/jaytaylor/html2text;github.com/kardianos/osext;github.com/keybase/go-keychain;github.com/logrusorgru/aurora;github.com/Masterminds/semver/v3;github.com/mattn/go-runewidth;github.com/miekg/dns;github.com/myesui/uuid;github.com/nsf/jsondiff;github.com/olekukonko/tablewriter;github.com/pkg/errors;github.com/ProtonMail/bcrypt;github.com/ProtonMail/crypto;github.com/ProtonMail/docker-credential-helpers;github.com/ProtonMail/go-appdir;github.com/ProtonMail/go-apple-mobileconfig;github.com/ProtonMail/go-autostart;github.com/ProtonMail/go-imap;github.com/ProtonMail/go-imap-id;github.com/ProtonMail/gopenpgp/v2;github.com/ProtonMail/go-rfc5322;github.com/ProtonMail/go-vcard;github.com/PuerkitoBio/goquery;github.com/sirupsen/logrus;github.com/skratchdot/open-golang;github.com/ssor/bom;github.com/stretchr/testify;github.com/therecipe/qt;github.com/twinj/uuid;github.com/urfave/cli;go.etcd.io/bbolt;golang.org/x/crypto;golang.org/x/net;golang.org/x/text;gopkg.in/stretchr/testify.v1;;Font Awesome 4.7.0;;Qt 5.13 by Qt group;"
+const Credits = "github.com/0xAX/notificator;github.com/abiosoft/ishell;github.com/abiosoft/readline;github.com/allan-simon/go-singleinstance;github.com/chzyer/logex;github.com/chzyer/test;github.com/cucumber/godog;github.com/docker/docker-credential-helpers;github.com/emersion/go-imap;github.com/emersion/go-imap-appendlimit;github.com/emersion/go-imap-idle;github.com/emersion/go-imap-move;github.com/emersion/go-imap-quota;github.com/emersion/go-imap-specialuse;github.com/emersion/go-imap-unselect;github.com/emersion/go-mbox;github.com/emersion/go-message;github.com/emersion/go-sasl;github.com/emersion/go-smtp;github.com/emersion/go-textwrapper;github.com/emersion/go-vcard;github.com/fatih/color;github.com/flynn-archive/go-shlex;github.com/getsentry/sentry-go;github.com/golang/mock;github.com/google/go-cmp;github.com/google/uuid;github.com/gopherjs/gopherjs;github.com/go-resty/resty/v2;github.com/hashicorp/go-multierror;github.com/jameskeane/bcrypt;github.com/jaytaylor/html2text;github.com/keybase/go-keychain;github.com/logrusorgru/aurora;github.com/Masterminds/semver/v3;github.com/mattn/go-runewidth;github.com/miekg/dns;github.com/myesui/uuid;github.com/nsf/jsondiff;github.com/olekukonko/tablewriter;github.com/pkg/errors;github.com/ProtonMail/bcrypt;github.com/ProtonMail/crypto;github.com/ProtonMail/docker-credential-helpers;github.com/ProtonMail/go-appdir;github.com/ProtonMail/go-apple-mobileconfig;github.com/ProtonMail/go-autostart;github.com/ProtonMail/go-imap;github.com/ProtonMail/go-imap-id;github.com/ProtonMail/gopenpgp/v2;github.com/ProtonMail/go-rfc5322;github.com/ProtonMail/go-vcard;github.com/PuerkitoBio/goquery;github.com/sirupsen/logrus;github.com/skratchdot/open-golang;github.com/ssor/bom;github.com/stretchr/testify;github.com/therecipe/qt;github.com/twinj/uuid;github.com/urfave/cli/v2;go.etcd.io/bbolt;golang.org/x/crypto;golang.org/x/net;golang.org/x/text;gopkg.in/stretchr/testify.v1;;Font Awesome 4.7.0;;Qt 5.13 by Qt group;"

internal/importexport/importexport.go

@@ -36,23 +36,27 @@ var (
 type ImportExport struct {
 	*users.Users
 
-	config        Configer
+	locations     Locator
+	cache         Cacher
 	panicHandler  users.PanicHandler
 	clientManager users.ClientManager
 }
 
 func New(
-	config Configer,
+	locations Locator,
+	cache Cacher,
 	panicHandler users.PanicHandler,
 	eventListener listener.Listener,
 	clientManager users.ClientManager,
 	credStorer users.CredentialsStorer,
 ) *ImportExport {
-	u := users.New(config, panicHandler, eventListener, clientManager, credStorer, &storeFactory{}, false)
+	u := users.New(locations, panicHandler, eventListener, clientManager, credStorer, &storeFactory{}, false)
+
 	return &ImportExport{
 		Users: u,
 
-		config:        config,
+		locations:     locations,
+		cache:         cache,
 		panicHandler:  panicHandler,
 		clientManager: clientManager,
 	}
@@ -120,7 +124,11 @@ func (ie *ImportExport) GetLocalImporter(address, path string) (*transfer.Transf
 	if err != nil {
 		return nil, err
 	}
-	return transfer.New(ie.panicHandler, newImportMetricsManager(ie), ie.config.GetLogDir(), ie.config.GetTransferDir(), source, target)
+	logsPath, err := ie.locations.ProvideLogsPath()
+	if err != nil {
+		return nil, err
+	}
+	return transfer.New(ie.panicHandler, newImportMetricsManager(ie), logsPath, ie.cache.GetTransferDir(), source, target)
 }
 
 // GetRemoteImporter returns transferrer from remote IMAP to ProtonMail account.
@@ -133,7 +141,11 @@ func (ie *ImportExport) GetRemoteImporter(address, username, password, host, por
 	if err != nil {
 		return nil, err
 	}
-	return transfer.New(ie.panicHandler, newImportMetricsManager(ie), ie.config.GetLogDir(), ie.config.GetTransferDir(), source, target)
+	logsPath, err := ie.locations.ProvideLogsPath()
+	if err != nil {
+		return nil, err
+	}
+	return transfer.New(ie.panicHandler, newImportMetricsManager(ie), logsPath, ie.cache.GetTransferDir(), source, target)
 }
 
 // GetEMLExporter returns transferrer from ProtonMail account to local EML structure.
@@ -143,7 +155,11 @@ func (ie *ImportExport) GetEMLExporter(address, path string) (*transfer.Transfer
 		return nil, err
 	}
 	target := transfer.NewEMLProvider(path)
-	return transfer.New(ie.panicHandler, newExportMetricsManager(ie), ie.config.GetLogDir(), ie.config.GetTransferDir(), source, target)
+	logsPath, err := ie.locations.ProvideLogsPath()
+	if err != nil {
+		return nil, err
+	}
+	return transfer.New(ie.panicHandler, newExportMetricsManager(ie), logsPath, ie.cache.GetTransferDir(), source, target)
 }
 
 // GetMBOXExporter returns transferrer from ProtonMail account to local MBOX structure.
@@ -153,7 +169,11 @@ func (ie *ImportExport) GetMBOXExporter(address, path string) (*transfer.Transfe
 		return nil, err
 	}
 	target := transfer.NewMBOXProvider(path)
-	return transfer.New(ie.panicHandler, newExportMetricsManager(ie), ie.config.GetLogDir(), ie.config.GetTransferDir(), source, target)
+	logsPath, err := ie.locations.ProvideLogsPath()
+	if err != nil {
+		return nil, err
+	}
+	return transfer.New(ie.panicHandler, newExportMetricsManager(ie), logsPath, ie.cache.GetTransferDir(), source, target)
 }
 
 func (ie *ImportExport) getPMAPIProvider(address string) (*transfer.PMAPIProvider, error) {
@@ -167,5 +187,5 @@ func (ie *ImportExport) getPMAPIProvider(address string) (*transfer.PMAPIProvide
 		log.WithError(err).Info("Address does not exist, using all addresses")
 	}
 
-	return transfer.NewPMAPIProvider(ie.config.GetAPIConfig(), ie.clientManager, user.ID(), addressID)
+	return transfer.NewPMAPIProvider(ie.clientManager, user.ID(), addressID)
 }

internal/importexport/types.go

@@ -17,11 +17,11 @@
 
 package importexport
 
-import "github.com/ProtonMail/proton-bridge/internal/users"
+type Locator interface {
+	ProvideLogsPath() (string, error)
+	Clear() error
+}
 
-type Configer interface {
-	users.Configer
-
-	GetLogDir() string
+type Cacher interface {
 	GetTransferDir() string
 }

internal/locations/locations.go

@@ -0,0 +1,191 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+// Package locations implements a type that provides cross-platform access to
+// standard filesystem locations, including config, cache and log directories.
+package locations
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+
+	"github.com/ProtonMail/proton-bridge/pkg/files"
+	"github.com/sirupsen/logrus"
+)
+
+// Locations provides cross-platform access to standard locations.
+// On linux:
+// - settings: ~/.config/protonmail/<app>
+// - logs: ~/.cache/protonmail/<app>/logs
+// - cache: ~/.cache/protonmail/<app>/cache
+// - updates: ~/.cache/protonmail/<app>/updates
+// - lockfile: ~/.cache/protonmail/<app>/<app>.lock
+type Locations struct {
+	userConfig, userCache string
+	configName            string
+}
+
+type appDirsProvider interface {
+	UserConfig() string
+	UserCache() string
+}
+
+func New(appDirs appDirsProvider, configName string) *Locations {
+	return &Locations{
+		userConfig: appDirs.UserConfig(),
+		userCache:  appDirs.UserCache(),
+		configName: configName,
+	}
+}
+
+// GetLockFile returns the path to the lock file (e.g. ~/.cache/<company>/<app>/<app>.lock).
+func (l *Locations) GetLockFile() string {
+	return filepath.Join(l.userCache, l.configName+".lock")
+}
+
+// GetLicenseFilePath returns path to liense file.
+func (l *Locations) GetLicenseFilePath() string {
+	path := l.getLicenseFilePath()
+	logrus.WithField("path", path).Info("License file path")
+	return path
+}
+
+func (l *Locations) getLicenseFilePath() string {
+	// User can install app to different location, or user can run it
+	// directly from the package without installation, or it could be
+	// automatically updated (app started from differenet location).
+	// For all those cases, first let's check LICENSE next to the binary.
+	path := filepath.Join(filepath.Dir(os.Args[0]), "LICENSE")
+	if _, err := os.Stat(path); err == nil {
+		return path
+	}
+
+	switch runtime.GOOS {
+	case "linux":
+		appName := l.configName
+		if l.configName == "importExport" {
+			appName = "import-export"
+		}
+		// Most Linux distributions.
+		path := "/usr/share/doc/protonmail/" + appName + "/LICENSE"
+		if _, err := os.Stat(path); err == nil {
+			return path
+		}
+		// Arch distributions.
+		return "/usr/share/licenses/protonmail-" + appName + "/LICENSE"
+	case "darwin": //nolint[goconst]
+		path := filepath.Join(filepath.Dir(os.Args[0]), "..", "Resources", "LICENSE")
+		if _, err := os.Stat(path); err == nil {
+			return path
+		}
+
+		appName := "ProtonMail Bridge.app"
+		if l.configName == "importExport" {
+			appName = "ProtonMail Import-Export.app"
+		}
+		return "/Applications/" + appName + "/Contents/Resources/LICENSE"
+	case "windows":
+		path := filepath.Join(filepath.Dir(os.Args[0]), "LICENSE.txt")
+		if _, err := os.Stat(path); err == nil {
+			return path
+		}
+		// This should not happen, Windows should be handled by relative
+		// location to the binary above. This is just fallback which may
+		// or may not work, depends where user installed the app and how
+		// user started the app.
+		return filepath.FromSlash("C:/Program Files/Proton Technologies AG/ProtonMail Bridge/LICENSE.txt")
+	}
+	return ""
+}
+
+// ProvideSettingsPath returns a location for user settings (e.g. ~/.config/<company>/<app>).
+// It creates it if it doesn't already exist.
+func (l *Locations) ProvideSettingsPath() (string, error) {
+	if err := os.MkdirAll(l.getSettingsPath(), 0700); err != nil {
+		return "", err
+	}
+
+	return l.getSettingsPath(), nil
+}
+
+// ProvideLogsPath returns a location for user logs (e.g. ~/.cache/<company>/<app>/logs).
+// It creates it if it doesn't already exist.
+func (l *Locations) ProvideLogsPath() (string, error) {
+	if err := os.MkdirAll(l.getLogsPath(), 0700); err != nil {
+		return "", err
+	}
+
+	return l.getLogsPath(), nil
+}
+
+// ProvideCachePath returns a location for user cache dirs (e.g. ~/.cache/<company>/<app>/cache).
+// It creates it if it doesn't already exist.
+func (l *Locations) ProvideCachePath() (string, error) {
+	if err := os.MkdirAll(l.getCachePath(), 0700); err != nil {
+		return "", err
+	}
+
+	return l.getCachePath(), nil
+}
+
+// ProvideUpdatesPath returns a location for update files (e.g. ~/.cache/<company>/<app>/updates).
+// It creates it if it doesn't already exist.
+func (l *Locations) ProvideUpdatesPath() (string, error) {
+	if err := os.MkdirAll(l.getUpdatesPath(), 0700); err != nil {
+		return "", err
+	}
+
+	return l.getUpdatesPath(), nil
+}
+
+func (l *Locations) getSettingsPath() string {
+	return l.userConfig
+}
+
+func (l *Locations) getLogsPath() string {
+	return filepath.Join(l.userCache, "logs")
+}
+
+func (l *Locations) getCachePath() string {
+	return filepath.Join(l.userCache, "cache")
+}
+
+func (l *Locations) getUpdatesPath() string {
+	return filepath.Join(l.userCache, "updates")
+}
+
+// Clear removes everything except the lock file.
+func (l *Locations) Clear() error {
+	return files.Remove(
+		l.getSettingsPath(),
+		l.getLogsPath(),
+		l.getCachePath(),
+		l.getUpdatesPath(),
+	).Do()
+}
+
+// Clean removes any unexpected files from the app cache folder
+// while leaving files in the standard locations untouched.
+func (l *Locations) Clean() error {
+	return files.Remove(l.userCache).Except(
+		l.GetLockFile(),
+		l.getLogsPath(),
+		l.getCachePath(),
+		l.getUpdatesPath(),
+	).Do()
+}

internal/locations/locations_test.go

@@ -0,0 +1,152 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package locations
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type fakeAppDirs struct {
+	configDir, cacheDir string
+}
+
+func (dirs *fakeAppDirs) UserConfig() string {
+	return dirs.configDir
+}
+
+func (dirs *fakeAppDirs) UserCache() string {
+	return dirs.cacheDir
+}
+
+func TestClearRemovesEverythingExceptLockFile(t *testing.T) {
+	l := newTestLocations(t)
+
+	assert.NoError(t, l.Clear())
+
+	assert.FileExists(t, l.GetLockFile())
+	assert.NoDirExists(t, l.getSettingsPath())
+	assert.NoDirExists(t, l.getLogsPath())
+	assert.NoDirExists(t, l.getCachePath())
+	assert.NoDirExists(t, l.getUpdatesPath())
+}
+
+func TestCleanLeavesStandardLocationsUntouched(t *testing.T) {
+	l := newTestLocations(t)
+
+	createFilesInDir(t, l.getLogsPath(),
+		"log1.txt",
+		"log2.txt",
+	)
+
+	assert.NoError(t, l.Clean())
+
+	assert.FileExists(t, l.GetLockFile())
+	assert.DirExists(t, l.getSettingsPath())
+	assert.DirExists(t, l.getLogsPath())
+	assert.FileExists(t, filepath.Join(l.getLogsPath(), "log1.txt"))
+	assert.FileExists(t, filepath.Join(l.getLogsPath(), "log2.txt"))
+	assert.DirExists(t, l.getCachePath())
+	assert.DirExists(t, l.getUpdatesPath())
+}
+
+func TestCleanRemovesUnexpectedFilesAndFolders(t *testing.T) {
+	l := newTestLocations(t)
+
+	createFilesInDir(t, l.userCache,
+		"unexpected1.txt",
+		"dir1/unexpected2.txt",
+		"dir1/unexpected3.txt",
+		"dir2/unexpected4.txt",
+		"dir3/dir4/unexpected5.txt",
+	)
+
+	require.FileExists(t, filepath.Join(l.userCache, "unexpected1.txt"))
+	require.FileExists(t, filepath.Join(l.userCache, "dir1", "unexpected2.txt"))
+	require.FileExists(t, filepath.Join(l.userCache, "dir1", "unexpected3.txt"))
+	require.FileExists(t, filepath.Join(l.userCache, "dir2", "unexpected4.txt"))
+	require.FileExists(t, filepath.Join(l.userCache, "dir3", "dir4", "unexpected5.txt"))
+
+	assert.NoError(t, l.Clean())
+
+	assert.FileExists(t, l.GetLockFile())
+	assert.DirExists(t, l.getSettingsPath())
+	assert.DirExists(t, l.getLogsPath())
+	assert.DirExists(t, l.getCachePath())
+	assert.DirExists(t, l.getUpdatesPath())
+
+	assert.NoFileExists(t, filepath.Join(l.userCache, "unexpected1.txt"))
+	assert.NoFileExists(t, filepath.Join(l.userCache, "dir1", "unexpected2.txt"))
+	assert.NoFileExists(t, filepath.Join(l.userCache, "dir1", "unexpected3.txt"))
+	assert.NoFileExists(t, filepath.Join(l.userCache, "dir2", "unexpected4.txt"))
+	assert.NoFileExists(t, filepath.Join(l.userCache, "dir3", "dir4", "unexpected5.txt"))
+}
+
+func newFakeAppDirs(t *testing.T) *fakeAppDirs {
+	configDir, err := ioutil.TempDir("", "test-locations-config")
+	require.NoError(t, err)
+
+	cacheDir, err := ioutil.TempDir("", "test-locations-cache")
+	require.NoError(t, err)
+
+	return &fakeAppDirs{
+		configDir: configDir,
+		cacheDir:  cacheDir,
+	}
+}
+
+func newTestLocations(t *testing.T) *Locations {
+	l := New(newFakeAppDirs(t), "configName")
+
+	lock := l.GetLockFile()
+	createFilesInDir(t, "", lock)
+	require.FileExists(t, lock)
+
+	settings, err := l.ProvideSettingsPath()
+	require.NoError(t, err)
+	require.DirExists(t, settings)
+
+	logs, err := l.ProvideLogsPath()
+	require.NoError(t, err)
+	require.DirExists(t, logs)
+
+	cache, err := l.ProvideCachePath()
+	require.NoError(t, err)
+	require.DirExists(t, cache)
+
+	updates, err := l.ProvideUpdatesPath()
+	require.NoError(t, err)
+	require.DirExists(t, updates)
+
+	return l
+}
+
+func createFilesInDir(t *testing.T, dir string, files ...string) {
+	for _, target := range files {
+		require.NoError(t, os.MkdirAll(filepath.Dir(filepath.Join(dir, target)), 0700))
+
+		f, err := os.Create(filepath.Join(dir, target))
+		require.NoError(t, err)
+		require.NoError(t, f.Close())
+	}
+}

internal/logging/clear.go

@@ -0,0 +1,85 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package logging
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"sort"
+
+	"github.com/sirupsen/logrus"
+)
+
+func clearLogs(logDir string, maxLogs int) error {
+	files, err := ioutil.ReadDir(logDir)
+	if err != nil {
+		return err
+	}
+
+	var logsWithPrefix []string
+	var crashesWithPrefix []string
+
+	for _, file := range files {
+		if matchLogName(file.Name()) {
+			if matchStackTraceName(file.Name()) {
+				crashesWithPrefix = append(crashesWithPrefix, file.Name())
+			} else {
+				logsWithPrefix = append(logsWithPrefix, file.Name())
+			}
+		} else {
+			// Older versions of Bridge stored logs in subfolders for each version.
+			// That also has to be cleared and the functionality can be removed after some time.
+			if file.IsDir() {
+				if err := clearLogs(filepath.Join(logDir, file.Name()), maxLogs); err != nil {
+					return err
+				}
+			} else {
+				removeLog(logDir, file.Name())
+			}
+		}
+	}
+
+	removeOldLogs(logDir, logsWithPrefix, maxLogs)
+	removeOldLogs(logDir, crashesWithPrefix, maxLogs)
+
+	return nil
+}
+
+func removeOldLogs(logDir string, filenames []string, maxLogs int) {
+	count := len(filenames)
+	if count <= maxLogs {
+		return
+	}
+
+	sort.Strings(filenames) // Sorted by timestamp: oldest first.
+	for _, filename := range filenames[:count-maxLogs] {
+		removeLog(logDir, filename)
+	}
+}
+
+func removeLog(logDir, filename string) {
+	// We need to be sure to delete only log files.
+	// Directory with logs can also contain other files.
+	if !matchLogName(filename) {
+		return
+	}
+	if err := os.RemoveAll(filepath.Join(logDir, filename)); err != nil {
+		logrus.WithError(err).Error("Failed to remove old logs")
+	}
+}

internal/logging/crash.go

@@ -0,0 +1,62 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package logging
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime/pprof"
+	"time"
+
+	"github.com/ProtonMail/proton-bridge/internal/constants"
+	"github.com/ProtonMail/proton-bridge/internal/crash"
+	"github.com/sirupsen/logrus"
+)
+
+func DumpStackTrace(logsPath string) crash.RecoveryAction {
+	return func(r interface{}) error {
+		file := filepath.Join(logsPath, getStackTraceName(constants.Version, constants.Revision))
+
+		f, err := os.OpenFile(file, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0600)
+		if err != nil {
+			return err
+		}
+
+		if _, err := f.WriteString(fmt.Sprintf("Recover: %v", r)); err != nil {
+			return err
+		}
+
+		if err := pprof.Lookup("goroutine").WriteTo(f, 2); err != nil {
+			return err
+		}
+
+		logrus.WithField("file", file).Warn("Saved crash report")
+
+		return nil
+	}
+}
+
+func getStackTraceName(version, revision string) string {
+	return fmt.Sprintf("v%v_%v_crash_%v.log", version, revision, time.Now().Unix())
+}
+
+func matchStackTraceName(name string) bool {
+	return regexp.MustCompile(`^v.*_crash_.*\.log$`).MatchString(name)
+}

internal/logging/logging.go

@@ -0,0 +1,90 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package logging
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+	"time"
+
+	"github.com/ProtonMail/proton-bridge/internal/constants"
+	"github.com/sirupsen/logrus"
+	"github.com/sirupsen/logrus/hooks/writer"
+)
+
+const (
+	// MaxLogSize defines the maximum log size we should permit.
+	// Zendesk has a file size limit of 20MB. When the last N log files are zipped,
+	// it should fit under 20MB. So here we permit up to 10MB (most files are a few hundred kB).
+	MaxLogSize = 10 * 2 << 20
+
+	// MaxLogs defines how many old log files should be kept.
+	MaxLogs = 3
+)
+
+func Init(logsPath string) error {
+	logrus.SetFormatter(&logrus.TextFormatter{
+		FullTimestamp:   true,
+		TimestampFormat: time.StampMilli,
+	})
+
+	rotator, err := NewRotator(MaxLogSize, func() (io.WriteCloser, error) {
+		if err := clearLogs(logsPath, MaxLogs); err != nil {
+			return nil, err
+		}
+
+		return os.Create(filepath.Join(logsPath, getLogName(constants.Version, constants.Revision)))
+	})
+	if err != nil {
+		return err
+	}
+
+	logrus.SetOutput(rotator)
+
+	logrus.AddHook(&writer.Hook{
+		Writer: os.Stderr,
+		LogLevels: []logrus.Level{
+			logrus.PanicLevel,
+			logrus.FatalLevel,
+			logrus.ErrorLevel,
+		},
+	})
+
+	return nil
+}
+
+func SetLevel(level string) {
+	if lvl, err := logrus.ParseLevel(level); err == nil {
+		logrus.SetLevel(lvl)
+	}
+
+	if logrus.GetLevel() == logrus.DebugLevel || logrus.GetLevel() == logrus.TraceLevel {
+		logrus.SetOutput(os.Stderr)
+	}
+}
+
+func getLogName(version, revision string) string {
+	return fmt.Sprintf("v%v_%v_%v.log", version, revision, time.Now().Unix())
+}
+
+func matchLogName(name string) bool {
+	return regexp.MustCompile(`^v.*\.log$`).MatchString(name)
+}

internal/logging/logging_test.go

@@ -0,0 +1,69 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package logging
+
+import (
+	"io/ioutil"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// TestClearLogs tests that cearLogs removes only bridge old log files keeping last three of them.
+func TestClearLogs(t *testing.T) {
+	dir, err := ioutil.TempDir("", "clear-logs-test")
+	require.NoError(t, err)
+
+	require.NoError(t, ioutil.WriteFile(filepath.Join(dir, "other.log"), []byte("Hello"), 0755))
+	require.NoError(t, ioutil.WriteFile(filepath.Join(dir, "v1_10.log"), []byte("Hello"), 0755))
+	require.NoError(t, ioutil.WriteFile(filepath.Join(dir, "v1_11.log"), []byte("Hello"), 0755))
+	require.NoError(t, ioutil.WriteFile(filepath.Join(dir, "v2_12.log"), []byte("Hello"), 0755))
+	require.NoError(t, ioutil.WriteFile(filepath.Join(dir, "v2_13.log"), []byte("Hello"), 0755))
+
+	require.NoError(t, clearLogs(dir, 3))
+	checkFileNames(t, dir, []string{
+		"other.log",
+		"v1_11.log",
+		"v2_12.log",
+		"v2_13.log",
+	})
+}
+
+func checkFileNames(t *testing.T, dir string, expectedFileNames []string) {
+	fileNames := getFileNames(t, dir)
+	require.Equal(t, expectedFileNames, fileNames)
+}
+
+func getFileNames(t *testing.T, dir string) []string {
+	files, err := ioutil.ReadDir(dir)
+	require.NoError(t, err)
+
+	fileNames := []string{}
+	for _, file := range files {
+		fileNames = append(fileNames, file.Name())
+		if file.IsDir() {
+			subDir := filepath.Join(dir, file.Name())
+			subFileNames := getFileNames(t, subDir)
+			for _, subFileName := range subFileNames {
+				fileNames = append(fileNames, file.Name()+"/"+subFileName)
+			}
+		}
+	}
+	return fileNames
+}

internal/logging/rotator.go

@@ -0,0 +1,75 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package logging
+
+import "io"
+
+type Rotator struct {
+	getFile FileProvider
+	wc      io.WriteCloser
+	size    int
+	maxSize int
+}
+
+type FileProvider func() (io.WriteCloser, error)
+
+func NewRotator(maxSize int, getFile FileProvider) (*Rotator, error) {
+	r := &Rotator{
+		getFile: getFile,
+		maxSize: maxSize,
+	}
+
+	if err := r.rotate(); err != nil {
+		return nil, err
+	}
+
+	return r, nil
+}
+
+func (r *Rotator) Write(p []byte) (int, error) {
+	if r.size+len(p) > r.maxSize {
+		if err := r.rotate(); err != nil {
+			return 0, err
+		}
+	}
+
+	n, err := r.wc.Write(p)
+	if err != nil {
+		return n, err
+	}
+
+	r.size += n
+
+	return n, nil
+}
+
+func (r *Rotator) rotate() error {
+	if r.wc != nil {
+		_ = r.wc.Close()
+	}
+
+	wc, err := r.getFile()
+	if err != nil {
+		return err
+	}
+
+	r.wc = wc
+	r.size = 0
+
+	return nil
+}

internal/logging/rotator_test.go

@@ -0,0 +1,131 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package logging
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type WriteCloser struct {
+	bytes.Buffer
+}
+
+func (c *WriteCloser) Close() error {
+	return nil
+}
+
+func TestRotator(t *testing.T) {
+	n := 0
+
+	getFile := func() (io.WriteCloser, error) {
+		n++
+		return &WriteCloser{}, nil
+	}
+
+	r, err := NewRotator(10, getFile)
+	require.NoError(t, err)
+
+	_, err = r.Write([]byte("12345"))
+	require.NoError(t, err)
+	assert.Equal(t, 1, n)
+
+	_, err = r.Write([]byte("12345"))
+	require.NoError(t, err)
+	assert.Equal(t, 1, n)
+
+	_, err = r.Write([]byte("01234"))
+	require.NoError(t, err)
+	assert.Equal(t, 2, n)
+
+	_, err = r.Write([]byte("01234"))
+	require.NoError(t, err)
+	assert.Equal(t, 2, n)
+
+	_, err = r.Write([]byte("01234"))
+	require.NoError(t, err)
+	assert.Equal(t, 3, n)
+
+	_, err = r.Write([]byte("01234"))
+	require.NoError(t, err)
+	assert.Equal(t, 3, n)
+
+	_, err = r.Write([]byte("01234"))
+	require.NoError(t, err)
+	assert.Equal(t, 4, n)
+}
+
+func BenchmarkRotateRAMFile(b *testing.B) {
+	dir, err := ioutil.TempDir("", "rotate-benchmark")
+	require.NoError(b, err)
+	defer os.RemoveAll(dir) // nolint[errcheck]
+
+	benchRotate(b, MaxLogSize, getTestFile(b, dir, MaxLogSize-1))
+}
+
+func BenchmarkRotateDiskFile(b *testing.B) {
+	cache, err := os.UserCacheDir()
+	require.NoError(b, err)
+
+	dir, err := ioutil.TempDir(cache, "rotate-benchmark")
+	require.NoError(b, err)
+	defer os.RemoveAll(dir) // nolint[errcheck]
+
+	benchRotate(b, MaxLogSize, getTestFile(b, dir, MaxLogSize-1))
+}
+
+func benchRotate(b *testing.B, logSize int, getFile func() (io.WriteCloser, error)) {
+	r, err := NewRotator(logSize, getFile)
+	require.NoError(b, err)
+
+	for n := 0; n < b.N; n++ {
+		require.NoError(b, r.rotate())
+
+		f, ok := r.wc.(*os.File)
+		require.True(b, ok)
+		require.NoError(b, os.Remove(f.Name()))
+	}
+}
+
+func getTestFile(b *testing.B, dir string, length int) func() (io.WriteCloser, error) {
+	return func() (io.WriteCloser, error) {
+		b.StopTimer()
+		defer b.StartTimer()
+
+		f, err := ioutil.TempFile(dir, "log")
+		if err != nil {
+			return nil, err
+		}
+
+		if _, err := f.Write(make([]byte, length)); err != nil {
+			return nil, err
+		}
+
+		if err := f.Sync(); err != nil {
+			return nil, err
+		}
+
+		return f, nil
+	}
+}

internal/smtp/backend.go

@@ -22,8 +22,7 @@ import (
 	"time"
 
 	"github.com/ProtonMail/proton-bridge/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/internal/preferences"
-	"github.com/ProtonMail/proton-bridge/pkg/config"
+	"github.com/ProtonMail/proton-bridge/internal/config/settings"
 	"github.com/ProtonMail/proton-bridge/pkg/confirmer"
 	"github.com/ProtonMail/proton-bridge/pkg/listener"
 	goSMTPBackend "github.com/emersion/go-smtp"
@@ -35,10 +34,14 @@ type panicHandler interface {
 	HandlePanic()
 }
 
+type settingsProvider interface {
+	GetBool(string) bool
+}
+
 type smtpBackend struct {
 	panicHandler  panicHandler
 	eventListener listener.Listener
-	preferences   *config.Preferences
+	settings      settingsProvider
 	bridge        bridger
 	confirmer     *confirmer.Confirmer
 	sendRecorder  *sendRecorder
@@ -48,22 +51,22 @@ type smtpBackend struct {
 func NewSMTPBackend(
 	panicHandler panicHandler,
 	eventListener listener.Listener,
-	preferences *config.Preferences,
+	settings settingsProvider,
 	bridge *bridge.Bridge,
 ) *smtpBackend { //nolint[golint]
-	return newSMTPBackend(panicHandler, eventListener, preferences, newBridgeWrap(bridge))
+	return newSMTPBackend(panicHandler, eventListener, settings, newBridgeWrap(bridge))
 }
 
 func newSMTPBackend(
 	panicHandler panicHandler,
 	eventListener listener.Listener,
-	preferences *config.Preferences,
+	settings settingsProvider,
 	bridge bridger,
 ) *smtpBackend {
 	return &smtpBackend{
 		panicHandler:  panicHandler,
 		eventListener: eventListener,
-		preferences:   preferences,
+		settings:      settings,
 		bridge:        bridge,
 		confirmer:     confirmer.New(),
 		sendRecorder:  newSendRecorder(),
@@ -109,7 +112,7 @@ func (sb *smtpBackend) AnonymousLogin(_ *goSMTPBackend.ConnectionState) (goSMTPB
 }
 
 func (sb *smtpBackend) shouldReportOutgoingNoEnc() bool {
-	return sb.preferences.GetBool(preferences.ReportOutgoingNoEncKey)
+	return sb.settings.GetBool(settings.ReportOutgoingNoEncKey)
 }
 
 func (sb *smtpBackend) ConfirmNoEncryption(messageID string, shouldSend bool) {

internal/smtp/server.go

@@ -43,6 +43,13 @@ func NewSMTPServer(debug bool, port int, useSSL bool, tls *tls.Config, smtpBacke
 	s.Domain = bridge.Host
 	s.AllowInsecureAuth = true
 
+	if debug {
+		fmt.Println("THE LOG WILL CONTAIN **DECRYPTED** MESSAGE DATA")
+		log.Warning("================================================")
+		log.Warning("THIS LOG WILL CONTAIN **DECRYPTED** MESSAGE DATA")
+		log.Warning("================================================")
+	}
+
 	if debug {
 		s.Debug = logrus.
 			WithField("pkg", "smtp/server").

internal/transfer/provider_imap_utils.go

@@ -24,7 +24,7 @@ import (
 	"time"
 
 	imapID "github.com/ProtonMail/go-imap-id"
-	"github.com/ProtonMail/proton-bridge/pkg/constants"
+	"github.com/ProtonMail/proton-bridge/internal/constants"
 	"github.com/ProtonMail/proton-bridge/pkg/pmapi"
 	"github.com/emersion/go-imap"
 	imapClient "github.com/emersion/go-imap/client"

internal/transfer/provider_pmapi.go

@@ -27,7 +27,6 @@ import (
 
 // PMAPIProvider implements import and export to/from ProtonMail server.
 type PMAPIProvider struct {
-	clientConfig  *pmapi.ClientConfig
 	clientManager ClientManager
 	userID        string
 	addressID     string
@@ -40,9 +39,8 @@ type PMAPIProvider struct {
 }
 
 // NewPMAPIProvider returns new PMAPIProvider.
-func NewPMAPIProvider(config *pmapi.ClientConfig, clientManager ClientManager, userID, addressID string) (*PMAPIProvider, error) {
+func NewPMAPIProvider(clientManager ClientManager, userID, addressID string) (*PMAPIProvider, error) {
 	provider := &PMAPIProvider{
-		clientConfig:  config,
 		clientManager: clientManager,
 		userID:        userID,
 		addressID:     addressID,

internal/transfer/provider_pmapi_target.go

@@ -26,7 +26,6 @@ import (
 
 	pkgMessage "github.com/ProtonMail/proton-bridge/pkg/message"
 	"github.com/ProtonMail/proton-bridge/pkg/pmapi"
-	"github.com/ProtonMail/proton-bridge/pkg/sentry"
 	"github.com/pkg/errors"
 )
 
@@ -247,22 +246,6 @@ func (p *PMAPIProvider) generateImportMsgReq(rules transferRules, progress *Prog
 func (p *PMAPIProvider) parseMessage(msg Message) (m *pmapi.Message, r []io.Reader, err error) {
 	p.timeIt.start("parse", msg.ID)
 	defer p.timeIt.stop("parse", msg.ID)
-
-	// Old message parser is panicking in some cases.
-	// Instead of crashing we try to convert to regular error.
-	defer func() {
-		if r := recover(); r != nil {
-			err = fmt.Errorf("panic while parse: %v", r)
-			if sentryErr := sentry.ReportSentryCrash(
-				p.clientConfig.ClientID,
-				p.clientConfig.AppVersion,
-				p.clientConfig.UserAgent,
-				err,
-			); sentryErr != nil {
-				log.Error("Sentry crash report failed: ", sentryErr)
-			}
-		}
-	}()
 	message, _, _, attachmentReaders, err := pkgMessage.Parse(bytes.NewBuffer(msg.Body))
 	return message, attachmentReaders, err
 }

internal/transfer/provider_pmapi_test.go

@@ -33,7 +33,7 @@ func TestPMAPIProviderMailboxes(t *testing.T) {
 	defer m.ctrl.Finish()
 
 	setupPMAPIClientExpectationForExport(&m)
-	provider, err := NewPMAPIProvider(m.pmapiConfig, m.clientManager, "user", "addressID")
+	provider, err := NewPMAPIProvider(m.clientManager, "user", "addressID")
 	r.NoError(t, err)
 
 	tests := []struct {
@@ -78,7 +78,7 @@ func TestPMAPIProviderTransferTo(t *testing.T) {
 	defer m.ctrl.Finish()
 
 	setupPMAPIClientExpectationForExport(&m)
-	provider, err := NewPMAPIProvider(m.pmapiConfig, m.clientManager, "user", "addressID")
+	provider, err := NewPMAPIProvider(m.clientManager, "user", "addressID")
 	r.NoError(t, err)
 
 	rules, rulesClose := newTestRules(t)
@@ -96,7 +96,7 @@ func TestPMAPIProviderTransferFrom(t *testing.T) {
 	defer m.ctrl.Finish()
 
 	setupPMAPIClientExpectationForImport(&m)
-	provider, err := NewPMAPIProvider(m.pmapiConfig, m.clientManager, "user", "addressID")
+	provider, err := NewPMAPIProvider(m.clientManager, "user", "addressID")
 	r.NoError(t, err)
 
 	rules, rulesClose := newTestRules(t)
@@ -114,7 +114,7 @@ func TestPMAPIProviderTransferFromDraft(t *testing.T) {
 	defer m.ctrl.Finish()
 
 	setupPMAPIClientExpectationForImportDraft(&m)
-	provider, err := NewPMAPIProvider(m.pmapiConfig, m.clientManager, "user", "addressID")
+	provider, err := NewPMAPIProvider(m.clientManager, "user", "addressID")
 	r.NoError(t, err)
 
 	rules, rulesClose := newTestRules(t)
@@ -133,9 +133,9 @@ func TestPMAPIProviderTransferFromTo(t *testing.T) {
 	setupPMAPIClientExpectationForExport(&m)
 	setupPMAPIClientExpectationForImport(&m)
 
-	source, err := NewPMAPIProvider(m.pmapiConfig, m.clientManager, "user", "addressID")
+	source, err := NewPMAPIProvider(m.clientManager, "user", "addressID")
 	r.NoError(t, err)
-	target, err := NewPMAPIProvider(m.pmapiConfig, m.clientManager, "user", "addressID")
+	target, err := NewPMAPIProvider(m.clientManager, "user", "addressID")
 	r.NoError(t, err)
 
 	rules, rulesClose := newTestRules(t)

internal/updater/channel_beta.go

@@ -15,12 +15,8 @@
 // You should have received a copy of the GNU General Public License
 // along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
 
-// +build build_qa
+// +build beta
 
-package updates
+package updater
 
-func init() {
-	Host = "https://bridgeteam.protontech.ch"
-	DownloadPath = "download/qa"
-	BuildType = "QA"
-}
+const Channel = "beta"

internal/updater/channel_default.go

@@ -15,14 +15,10 @@
 // You should have received a copy of the GNU General Public License
 // along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
 
-// Code generated by ./release-notes.sh at 'Mon Dec 28 02:39:43 PM CET 2020'. DO NOT EDIT.
+// +build !beta
 
-package importexport
+package updater
 
-const ReleaseNotes = `• Allow an import of already encrypted messages (as cypher text)
-• Cosmetic GUI changes
-• Better error handling
-`
-
-const ReleaseFixedBugs = `• Installation issues on linux
-`
+// Channel is the channel of updates users are subscribed to.
+// For now it is hardcoded in the build. In future, it might be selectable in settings.
+const Channel = "live"

internal/updater/host_default.go

@@ -0,0 +1,22 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+// +build !pmapi_qa
+
+package updater
+
+const Host = "https://protonmail.com/download"

internal/updater/host_qa.go

@@ -0,0 +1,22 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+// +build pmapi_qa
+
+package updater
+
+const Host = "https://bridgeteam.protontech.ch/bridgeteam/autoupdates/download"

internal/updater/install_darwin.go

@@ -0,0 +1,64 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package updater
+
+import (
+	"compress/gzip"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/Masterminds/semver/v3"
+	"github.com/ProtonMail/proton-bridge/internal/versioner"
+	"github.com/ProtonMail/proton-bridge/pkg/tar"
+	"github.com/pkg/errors"
+)
+
+type Installer struct{}
+
+func NewInstaller(*versioner.Versioner) *Installer {
+	return &Installer{}
+}
+
+func (i *Installer) InstallUpdate(_ *semver.Version, r io.Reader) error {
+	gr, err := gzip.NewReader(r)
+	if err != nil {
+		return err
+	}
+	defer func() { _ = gr.Close() }()
+
+	tempDir, err := ioutil.TempDir("", "proton-update-source")
+	if err != nil {
+		return errors.Wrap(err, "failed to get temporary update directory")
+	}
+
+	if err := tar.UntarToDir(gr, tempDir); err != nil {
+		return errors.Wrap(err, "failed to unpack update package")
+	}
+
+	exePath, err := os.Executable()
+	if err != nil {
+		return errors.Wrap(err, "failed to determine current executable path")
+	}
+
+	oldBundle := filepath.Dir(filepath.Dir(filepath.Dir(exePath)))
+	newBundle := filepath.Join(tempDir, filepath.Base(oldBundle))
+
+	return syncFolders(oldBundle, newBundle)
+}

internal/updater/install_default.go

@@ -0,0 +1,41 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+// +build !darwin
+
+package updater
+
+import (
+	"io"
+
+	"github.com/Masterminds/semver/v3"
+	"github.com/ProtonMail/proton-bridge/internal/versioner"
+)
+
+type Installer struct {
+	versioner *versioner.Versioner
+}
+
+func NewInstaller(versioner *versioner.Versioner) *Installer {
+	return &Installer{
+		versioner: versioner,
+	}
+}
+
+func (i *Installer) InstallUpdate(version *semver.Version, r io.Reader) error {
+	return i.versioner.InstallNewVersion(version, r)
+}

internal/updater/key_default.go

@@ -1,6 +1,28 @@
------BEGIN PGP PUBLIC KEY BLOCK-----
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
 
-mQINBFo9OeEBEAC+fPrLcUBY+YUc5YiMrYJQ6ogrJWMGC00h9fAv3PsrHkBz0z7c
+// +build !pmapi_qa
+
+package updater
+
+// DefaultPublicKey is the public key used to sign builds.
+const DefaultPublicKey = `-----BEGIN PGP PUBLIC KEY BLOCK-----
+
+xsFNBFo9OeEBEAC+fPrLcUBY+YUc5YiMrYJQ6ogrJWMGC00h9fAv3PsrHkBz0z7c
 QFDyNdNatokFDtZDX115M0vzDwk5NkcjmO7CWbf6nCZcwYqOSrBoH8wNT9uTS/6p
 R3AHk1r3C/36QG3iWx6Wg4ycRkXWYToT3/yh5waE5BbLi/9TSBAdfJzTyxt4IpZG
 3OTMnOwuz6eNRWVHkA48CJydWS6M8z+jIsBwFq4nOIChvLjIF42PuAT1VaiCYSmy
@@ -11,8 +33,8 @@ d1UzLPCSUNUO+/7fslZCax26d1r1kbHzJLAN1Jer6rxoEDaEiVSCUTnHgykCq5rO
 C3PScGEdOaIi4H5c6YFZrLmdz409YmJEWLKIPV/u5DpI+YGmAfAevrjkMBgQBOmZ
 D8Gp19LnRtmqjVh2rVdr8yc5nAjoNOZwanMwD5vCWPUVELWXubNFBv8hqZMxHZqW
 GrB8x8hkdgiNmuyqsxzBmOEJHWLlvbFhvHhIedT8paU/spL/qJmWp3EB4QARAQAB
-tExQcm90b24gVGVjaG5vbG9naWVzIEFHIChQcm90b25NYWlsIEJyaWRnZSBkZXZl
-bG9wZXJzKSA8YnJpZGdlQHByb3Rvbm1haWwuY2g+iQJUBBMBCAA+AhsDBQsJCAcC
+zUxQcm90b24gVGVjaG5vbG9naWVzIEFHIChQcm90b25NYWlsIEJyaWRnZSBkZXZl
+bG9wZXJzKSA8YnJpZGdlQHByb3Rvbm1haWwuY2g+wsGUBBMBCAA+AhsDBQsJCAcC
 BhUICQoLAgQWAgMBAh4BAheAFiEE1R5k0+Y+3D7veGTO4sddaOYjSwcFAlv377wF
 CQO83tsACgkQ4sddaOYjSwfhng//WNhZqr0StuN4KbYdQG+FY+aLijLhiVI3i4j6
 wUis+7UWFNMUGePsBUrF7zOrzo4Vp16FSRhhpveIbDMVJg4yGlzwN+jZr9FBvF8z
@@ -25,7 +47,7 @@ O1GihEpoXpOezs46+ER/YGx4ZF2ne2bmYnzoOOZBbGXwsMZTNaa9QJHbc1bz9jjj
 IFBc1zmrdi0nsbjlvLugEYIbSb/WP0wKwG66zTatslRIQ2unlUJNnWb0E4VLgz9y
 q57QpvxS7D312dZV0NnAwhyDI+54XAivXTQb0fAGfcgbtKdKpJb1dcAMb9WOBnpr
 BK7XLsWbJj5v5nB3AuWer7NhUyJB/ogWQtqRUY1bAcI4cB1zFwYq/PL0sbfAHDxx
-ZEF6Xhi5Ag0EWj054QEQALdPQOlRT1omHljxnN64jFuDXXSIb6zqaBvUwdYoDpV2
+ZEF6XhjOwU0EWj054QEQALdPQOlRT1omHljxnN64jFuDXXSIb6zqaBvUwdYoDpV2
 dfRmzGklsCVA7WHXBmDWbUe9avgO3OO7ANw6/JzzYjP+jwImpJg7cSqTqW8A1U6T
 YfGXVUV3a/obIEttl7bI9BsUNgmLsBYIwHov+gl/ajKQdALYHCmq3Bj6o7BBeWPp
 Vpk9dzjcsLVbmNszNGP1Ik5dKE0jZUi6h+YoVuJE9o/+T+jxoqFRpXNsZqWOEKmC
@@ -36,7 +58,7 @@ nnnUqvCcoekFMURDtP3z09KZXuOMnt834utd7WLe+LZD6dxs+rPhyDiW80E8Bdlz
 4Aip2hhFqWJAbUQXCyMaeU2WTWIzy0FQ6SEFFy/RM8O5O1HHsDYjtIic9QJ/PqSD
 0qN7LMlkjR8AdWvAxm95i5GpxDZODldsOneeummvsn3I1jCoULTik7iJVdRuY1V3
 vfsYAkefGN/n2ga3MvatCJipwoCGsMgUXGTdokXOqKBgMBuBLCkxj2wlol2R9p8R
-ABEBAAGJAjwEGAEIACYCGwwWIQTVHmTT5j7cPu94ZM7ix11o5iNLBwUCW/fygQUJ
+ABEBAAHCwXwEGAEIACYCGwwWIQTVHmTT5j7cPu94ZM7ix11o5iNLBwUCW/fygQUJ
 A7zhoAAKCRDix11o5iNLB7eTD/4x8I7I7MQV63Z8hDShJixSi49bfXeykzlrZyrA
 bqNr7JrIKzgX5F1HTU0JF3m+VGkhlpMIlTF/jLq9f1vzmRuiPvux/jItXYbnHFhh
 lFekwZkXx4nS5iwjpMDt6C1ERftv+Z5yHK91mZsr6eNcfA6VeIdKBQenltZvDVsq
@@ -49,5 +71,5 @@ b3mx3wudw+aI8MXXPzMBCAn57S7/xuQ4fODx62NOeme/BOnjASbeE3mZ5/3qBbnu
 YIgVTYNp5frIG3wK8W1r6NY2vYQ0iBIzOCIxnNDjYqsGlpAytX+SM+YY7J9n1dZa
 UsUfX5Qs+D9VIr/j3jurObPehn9fahCOC2YXicKgSbmQyBLysbFyLT5AMpn5aes0
 qdwhrw==
-=B6/F
------END PGP PUBLIC KEY BLOCK-----
+=mu62
+-----END PGP PUBLIC KEY BLOCK-----`

internal/updater/key_qa.go

@@ -0,0 +1,52 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+// +build pmapi_qa
+
+package updater
+
+// DefaultPublicKey is the public key used to sign builds.
+const DefaultPublicKey = `-----BEGIN PGP PUBLIC KEY BLOCK-----
+
+mQENBF9Q55wBCADiwBHGCyJiO2ZSDh9ZPecFKnf+JEryzqGYu3jImEoV2X5Bx/Kl
+5n3hHvao9jekEDFr1AjvSKfG9Zz/1GdionUUEdw76mkc7y09GKdXENOyCQYs7CV7
+WbWDSGSmp6DVBcRzRzMKm4zuB208a6Wwd2aYqIJ9Oo0l3ypQnox0BQCbbqewYSYN
+Dmj+WJkO+e2ovJQWrQgtpnj/QBX18KBjP4FiLSPHAyy7aC2t6JlTIz8UVAw2VZFn
+GBUUqnn0iy3W0nJNgv1ouo0rCa+eYBpz3n+GKTFWFDTIPQfZbh15nFJJgBSuiwyM
+sHjWCNJYu5PQmwNlGJJjtKw/9xgTFLC9yaNPABEBAAG0BkJyaWRnZYkBTgQTAQgA
+OBYhBH3hU445a9yHH+QknbtAQ7nyijPUBQJfUOecAhsDBQsJCAcCBhUKCQgLAgQW
+AgMBAh4BAheAAAoJELtAQ7nyijPUpisH/iznWGoma1PXpaQlD2241k9zSzg3Nczn
+yfm2mYtXlGVvjGLr29neErWpLy0Kb2ihKTTsgMkwSwcasBap8HYTtENNl1nUzQL7
+UhaASTzZ2jYw4Dypps+DYpoLm9RUWKHuUOE5Ov8QPjTBC/BswA0Lv1Z9u9t5qsdp
+UgB+YVYgRC+zSHMIzWSMx0dCSPgRilkPvIa5wB77J1+ZE7y1n/uQXOYrKitWrf+w
+tXcRYoPqYQ4KXIQ/PMCTwSEDDbsPD7F09AzYQPv6D20d7dyEf0/hlfpj+cvGyBG0
+GdGLjwjjKNA99ra1IXjgBUIEv/XpijfKK2D0FDiOdZi3JnVr8OYBCeW5AQ0EX1Dn
+nAEIAMtD5sLJ3hXE/bKRQaINx+7hzYhFOxzdGdOTlzlzEjsWYLmy2cWb2fjazIhf
+37g8HlSlMaHtHkdJIn1hS9+N76GxEChH31tF6Cuyz+k6TRqroNHsIxzOIjv3+qkM
+7xWPRhq8msB8ulWKBQtWpwVVC3sa/qTh9k29wuEiwQY0IxLV0a6BkE1TqK5/7A6Q
+o8SMCvQW6wAxPZMhPM/FwxMYxrKUT3UUDmRYS5RvSlMGUwK2HucQVU/qwsOPkJs4
+wq6RI+5NDtyGxMxUKod/GYpPaICUI/VNgIZXX6NNzS7JYEYBjtI/JOEOc0yQSh1u
+jEGl1k+4OLogUiV02mpGCrHutm0AEQEAAYkBNgQYAQgAIBYhBH3hU445a9yHH+Qk
+nbtAQ7nyijPUBQJfUOecAhsMAAoJELtAQ7nyijPU/wUIAKibg4GFxHFSiEjtzdlO
+2cIIr3yCsFmGFYVLF3JkOtVvQk7QDZTNsx5ZqC+Mtlf3Z04btG5M/FpHQ097orfl
+IH+bZVXMrYtzd4J7ujKGEJU2hY6a9j50odsiwl6CSrXdppS7RGdkhui0RCke/y9Z
+wJU5oyiWmcsQfhnET7DEpI7twqEwg43VBGOnaRxKFecyYsQVASlrWMENEpoaup8B
+oIS2nDvMVSSK77tmkNcLt8911VqZPtOYmxzM5rc+gm7Pn9kSZUXoGy4p5sFDu/mj
+zT1w+Qev2GlSVwFdKPasefLmb3lBEbNeZAkfFl48WEzwtK3VJM60Xl8RPFk0IKLe
+tXw=
+=aaxG
+-----END PGP PUBLIC KEY BLOCK-----`

internal/updater/locker.go

@@ -1,4 +1,4 @@
-// Copyright (c) 2021 Proton Technologies AG
+// Copyright (c) 2020 Proton Technologies AG
 //
 // This file is part of ProtonMail Bridge.
 //
@@ -15,18 +15,36 @@
 // You should have received a copy of the GNU General Public License
 // along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
 
-// Code generated by ./release-notes.sh at 'Wed Jan 13 03:17:24 PM CET 2021'. DO NOT EDIT.
+package updater
 
-package bridge
+import (
+	"sync/atomic"
 
-const ReleaseNotes = `• Improvements to message parsing
-• Better error handling
-`
+	"github.com/pkg/errors"
+)
 
-const ReleaseFixedBugs = `• Message corruption - rare cases of overly long headers
-• AppleMail crashes (related to timestamps)
-• Sending messages from aliases in combined inbox mode
-• Fedora font issues
+var ErrOperationOngoing = errors.New("the operation is already ongoing")
 
-For more detailed summary of the changes see https://github.com/ProtonMail/proton-bridge/blob/master/Changelog.md
-`
+// locker is an easy way to ensure we only perform one update at a time.
+type locker struct {
+	ongoing atomic.Value
+}
+
+func newLocker() *locker {
+	l := &locker{}
+
+	l.ongoing.Store(false)
+
+	return l
+}
+
+func (l *locker) doOnce(fn func() error) error {
+	if l.ongoing.Load().(bool) {
+		return ErrOperationOngoing
+	}
+
+	l.ongoing.Store(true)
+	defer func() { l.ongoing.Store(false) }()
+
+	return fn()
+}

internal/updater/locker_test.go

@@ -0,0 +1,67 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package updater
+
+import (
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestLocker(t *testing.T) {
+	l := newLocker()
+
+	assert.NoError(t, l.doOnce(func() error {
+		return nil
+	}))
+}
+
+func TestLockerForwardsErrors(t *testing.T) {
+	l := newLocker()
+
+	assert.Error(t, l.doOnce(func() error {
+		return errors.New("something went wrong")
+	}))
+}
+
+func TestLockerAllowsOnlyOneOperation(t *testing.T) {
+	l := newLocker()
+
+	wg := &sync.WaitGroup{}
+
+	wg.Add(1)
+	go func() {
+		assert.NoError(t, l.doOnce(func() error {
+			time.Sleep(2 * time.Second)
+			wg.Done()
+			return nil
+		}))
+	}()
+
+	time.Sleep(time.Second)
+
+	err := l.doOnce(func() error { return nil })
+	if assert.Error(t, err) {
+		assert.Equal(t, ErrOperationOngoing, err)
+	}
+
+	wg.Wait()
+}

internal/updater/sync.go

@@ -15,7 +15,7 @@
 // You should have received a copy of the GNU General Public License
 // along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
 
-package updates
+package updater
 
 import (
 	"crypto/sha256"
@@ -23,6 +23,8 @@ import (
 	"io"
 	"os"
 	"path/filepath"
+
+	"github.com/sirupsen/logrus"
 )
 
 func syncFolders(localPath, updatePath string) (err error) {
@@ -45,7 +47,7 @@ func syncFolders(localPath, updatePath string) (err error) {
 }
 
 func removeMissing(folderToCleanPath, itemsToKeepPath string) (err error) {
-	log.WithField("from", folderToCleanPath).Debug("Remove missing.")
+	logrus.WithField("from", folderToCleanPath).Debug("Remove missing")
 	// Create list of files.
 	existingRelPaths := map[string]bool{}
 	err = filepath.Walk(itemsToKeepPath, func(keepThis string, _ os.FileInfo, walkErr error) error {
@@ -56,7 +58,7 @@ func removeMissing(folderToCleanPath, itemsToKeepPath string) (err error) {
 		if walkErr != nil {
 			return walkErr
 		}
-		log.WithField("path", relPath).Trace("Keep the path.")
+		logrus.WithField("path", relPath).Trace("Keep the path")
 		existingRelPaths[relPath] = true
 		return nil
 	})
@@ -73,9 +75,9 @@ func removeMissing(folderToCleanPath, itemsToKeepPath string) (err error) {
 		if walkErr != nil {
 			return walkErr
 		}
-		log.Debug("check path ", relPath)
+		logrus.Debug("check path ", relPath)
 		if !existingRelPaths[relPath] {
-			log.Debug("path not in list, removing ", removeThis)
+			logrus.Debug("path not in list, removing ", removeThis)
 			delList = append(delList, removeThis)
 		}
 		return nil
@@ -86,7 +88,7 @@ func removeMissing(folderToCleanPath, itemsToKeepPath string) (err error) {
 
 	for _, removeThis := range delList {
 		if err = os.RemoveAll(removeThis); err != nil && !os.IsNotExist(err) {
-			log.Error("remove error ", err)
+			logrus.Error("remove error ", err)
 			return
 		}
 	}
@@ -95,18 +97,18 @@ func removeMissing(folderToCleanPath, itemsToKeepPath string) (err error) {
 }
 
 func restoreFromBackup(backupDir, localPath string) {
-	log.WithField("from", backupDir).
+	logrus.WithField("from", backupDir).
 		WithField("to", localPath).
 		Error("recovering")
 	if err := copyRecursively(backupDir, localPath); err != nil {
-		log.WithField("from", backupDir).
+		logrus.WithField("from", backupDir).
 			WithField("to", localPath).
 			Error("Not able to recover.")
 	}
 }
 
 func createBackup(srcFile, dstDir string) (err error) {
-	log.WithField("from", srcFile).WithField("to", dstDir).Debug("Create backup")
+	logrus.WithField("from", srcFile).WithField("to", dstDir).Debug("Create backup")
 	if err = mkdirAllClear(dstDir); err != nil {
 		return
 	}
@@ -114,6 +116,13 @@ func createBackup(srcFile, dstDir string) (err error) {
 	return copyRecursively(srcFile, dstDir)
 }
 
+func mkdirAllClear(path string) error {
+	if err := os.RemoveAll(path); err != nil {
+		return err
+	}
+	return os.MkdirAll(path, 0750)
+}
+
 // checksum assumes the file is a regular file and that it exists.
 func checksum(path string) (hash string) {
 	file, err := os.Open(path) //nolint[gosec]
@@ -143,7 +152,7 @@ func copyRecursively(srcDir, dstDir string) error { // nolint[funlen]
 
 		// Non regular source (e.g. named pipes, sockets, devices...).
 		if !srcIsLink && !srcIsDir && !srcInfo.Mode().IsRegular() {
-			log.Error("File ", srcPath, " with mode ", srcInfo.Mode())
+			logrus.Error("File ", srcPath, " with mode ", srcInfo.Mode())
 			return errors.New("irregular source file. Copy not implemented")
 		}
 
@@ -153,7 +162,7 @@ func copyRecursively(srcDir, dstDir string) error { // nolint[funlen]
 			return err
 		}
 		dstPath := filepath.Join(dstDir, srcRelPath)
-		log.Debug("src: ", srcPath, " dst: ", dstPath)
+		logrus.Debug("src: ", srcPath, " dst: ", dstPath)
 
 		// Destination exists.
 		dstInfo, err := os.Lstat(dstPath)
@@ -163,7 +172,7 @@ func copyRecursively(srcDir, dstDir string) error { // nolint[funlen]
 
 			// Non regular destination (e.g. named pipes, sockets, devices...).
 			if !dstIsLink && !dstIsDir && !dstInfo.Mode().IsRegular() {
-				log.Error("File ", dstPath, " with mode ", dstInfo.Mode())
+				logrus.Error("File ", dstPath, " with mode ", dstInfo.Mode())
 				return errors.New("irregular target file. Copy not implemented")
 			}
 
@@ -192,25 +201,25 @@ func copyRecursively(srcDir, dstDir string) error { // nolint[funlen]
 
 		// Create symbolic link and return.
 		if srcIsLink {
-			log.Debug("It is a symlink")
+			logrus.Debug("It is a symlink")
 			linkPath, err := os.Readlink(srcPath)
 			if err != nil {
 				return err
 			}
-			log.Debug("link to ", linkPath)
+			logrus.Debug("link to ", linkPath)
 			return os.Symlink(linkPath, dstPath)
 		}
 
 		// Create dir and return.
 		if srcIsDir {
-			log.Debug("It is a dir")
+			logrus.Debug("It is a dir")
 			return os.MkdirAll(dstPath, srcInfo.Mode())
 		}
 
 		// Regular files only.
 		// If files are same return.
 		if os.SameFile(srcInfo, dstInfo) || checksum(srcPath) == checksum(dstPath) {
-			log.Debug("Same files, skip copy")
+			logrus.Debug("Same files, skip copy")
 			return nil
 		}
 
@@ -225,7 +234,7 @@ func copyRecursively(srcDir, dstDir string) error { // nolint[funlen]
 }
 
 func copyToTmpFileRename(srcReader io.Reader, dstPath string, dstMode os.FileMode) error {
-	log.Debug("Tmp and rename ", dstPath)
+	logrus.Debug("Tmp and rename ", dstPath)
 	tmpPath := dstPath + ".tmp"
 	if err := copyToFileTruncate(srcReader, tmpPath, dstMode); err != nil {
 		return err
@@ -234,7 +243,7 @@ func copyToTmpFileRename(srcReader io.Reader, dstPath string, dstMode os.FileMod
 }
 
 func copyToFileTruncate(srcReader io.Reader, dstPath string, dstMode os.FileMode) error {
-	log.Debug("Copy and truncate ", dstPath)
+	logrus.Debug("Copy and truncate ", dstPath)
 	dstWriter, err := os.OpenFile(dstPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, dstMode)
 	if err != nil {
 		return err

internal/updater/sync_test.go

@@ -15,7 +15,7 @@
 // You should have received a copy of the GNU General Public License
 // along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
 
-package updates
+package updater
 
 import (
 	"io/ioutil"
@@ -40,7 +40,7 @@ func TestSyncFolder(t *testing.T) {
 	for _, srcType := range []string{EmptyType, FileType, SymlinkType, DirType} {
 		for _, dstType := range []string{EmptyType, FileType, SymlinkType, DirType} {
 			require.NoError(t, checkCopyWorks(srcType, dstType))
-			log.Warn("OK: from ", srcType, " to ", dstType)
+			logrus.Warn("OK: from ", srcType, " to ", dstType)
 		}
 	}
 }
@@ -52,13 +52,13 @@ func checkCopyWorks(srcType, dstType string) error {
 	destDir := filepath.Join(AppCacheDir, "sync_dst", dirName)
 
 	// clear before
-	log.Info("remove all ", srcDir)
+	logrus.Info("remove all ", srcDir)
 	err := os.RemoveAll(srcDir)
 	if err != nil {
 		return err
 	}
 
-	log.Info("remove all ", destDir)
+	logrus.Info("remove all ", destDir)
 	err = os.RemoveAll(destDir)
 	if err != nil {
 		return err
@@ -76,27 +76,27 @@ func checkCopyWorks(srcType, dstType string) error {
 	}
 
 	// copy
-	log.Info("Sync from ", srcDir, " to ", destDir)
+	logrus.Info("Sync from ", srcDir, " to ", destDir)
 	err = syncFolders(destDir, srcDir)
 	if err != nil {
 		return err
 	}
 
 	// Check
-	log.Info("check ", srcDir, " and ", destDir)
+	logrus.Info("check ", srcDir, " and ", destDir)
 	err = checkThatFilesAreSame(srcDir, destDir)
 	if err != nil {
 		return err
 	}
 
 	// clear after
-	log.Info("remove all ", srcDir)
+	logrus.Info("remove all ", srcDir)
 	err = os.RemoveAll(srcDir)
 	if err != nil {
 		return err
 	}
 
-	log.Info("remove all ", destDir)
+	logrus.Info("remove all ", destDir)
 	err = os.RemoveAll(destDir)
 	if err != nil {
 		return err
@@ -107,13 +107,13 @@ func checkCopyWorks(srcType, dstType string) error {
 
 func checkThatFilesAreSame(src, dst string) error {
 	cmd := exec.Command("diff", "-qr", src, dst) //nolint[gosec]
-	cmd.Stderr = log.WriterLevel(logrus.ErrorLevel)
-	cmd.Stdout = log.WriterLevel(logrus.InfoLevel)
+	cmd.Stderr = logrus.StandardLogger().WriterLevel(logrus.ErrorLevel)
+	cmd.Stdout = logrus.StandardLogger().WriterLevel(logrus.InfoLevel)
 	return cmd.Run()
 }
 
 func createTestFolder(dirPath, dirType string) error {
-	log.Info("creating folder ", dirPath, " type ", dirType)
+	logrus.Info("creating folder ", dirPath, " type ", dirType)
 	if dirType == NewType {
 		return nil
 	}

internal/updater/updater.go

@@ -0,0 +1,167 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package updater
+
+import (
+	"encoding/json"
+	"io"
+	"time"
+
+	"github.com/Masterminds/semver/v3"
+	"github.com/ProtonMail/gopenpgp/v2/crypto"
+	"github.com/ProtonMail/proton-bridge/pkg/pmapi"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+)
+
+type clientProvider interface {
+	GetAnonymousClient() pmapi.Client
+}
+
+type installer interface {
+	InstallUpdate(*semver.Version, io.Reader) error
+}
+
+type Updater struct {
+	cm        clientProvider
+	installer installer
+	kr        *crypto.KeyRing
+
+	curVer        *semver.Version
+	updateURLName string
+	platform      string
+	rollout       float64
+
+	locker *locker
+}
+
+func New(
+	cm clientProvider,
+	installer installer,
+	kr *crypto.KeyRing,
+	curVer *semver.Version,
+	updateURLName, platform string,
+	rollout float64,
+) *Updater {
+	return &Updater{
+		cm:            cm,
+		installer:     installer,
+		kr:            kr,
+		curVer:        curVer,
+		updateURLName: updateURLName,
+		platform:      platform,
+		rollout:       rollout,
+		locker:        newLocker(),
+	}
+}
+
+func (u *Updater) Watch(
+	period time.Duration,
+	handleUpdate func(VersionInfo) error,
+	handleError func(error),
+) func() {
+	logrus.WithField("period", period).Info("Watching for updates")
+
+	ticker := time.NewTicker(period)
+
+	go func() {
+		for {
+			u.watch(handleUpdate, handleError)
+			<-ticker.C
+		}
+	}()
+
+	return ticker.Stop
+}
+
+func (u *Updater) watch(
+	handleUpdate func(VersionInfo) error,
+	handleError func(error),
+) {
+	logrus.Info("Checking for updates")
+
+	latest, err := u.fetchVersionInfo()
+	if err != nil {
+		handleError(errors.Wrap(err, "failed to fetch version info"))
+		return
+	}
+
+	if !latest.Version.GreaterThan(u.curVer) || u.rollout > latest.Rollout {
+		logrus.WithError(err).Debug("No need to update")
+		return
+	}
+
+	if u.curVer.LessThan(latest.MinAuto) {
+		logrus.Debug("A manual update is required")
+		// NOTE: Need to notify user that they must update manually.
+		return
+	}
+
+	logrus.
+		WithField("latest", latest.Version).
+		WithField("current", u.curVer).
+		Info("An update is available")
+
+	if err := handleUpdate(latest); err != nil {
+		handleError(errors.Wrap(err, "failed to handle update"))
+	}
+}
+
+func (u *Updater) InstallUpdate(update VersionInfo) error {
+	return u.locker.doOnce(func() error {
+		logrus.WithField("package", update.Package).Info("Installing update package")
+
+		client := u.cm.GetAnonymousClient()
+		defer client.Logout()
+
+		r, err := client.DownloadAndVerify(update.Package, update.Package+".sig", u.kr)
+		if err != nil {
+			return errors.Wrap(err, "failed to download and verify update package")
+		}
+
+		if err := u.installer.InstallUpdate(update.Version, r); err != nil {
+			return errors.Wrap(err, "failed to install update package")
+		}
+
+		u.curVer = update.Version
+
+		return nil
+	})
+}
+
+func (u *Updater) fetchVersionInfo() (VersionInfo, error) {
+	client := u.cm.GetAnonymousClient()
+	defer client.Logout()
+
+	r, err := client.DownloadAndVerify(
+		u.getVersionFileURL(),
+		u.getVersionFileURL()+".sig",
+		u.kr,
+	)
+	if err != nil {
+		return VersionInfo{}, err
+	}
+
+	var versionMap VersionMap
+
+	if err := json.NewDecoder(r).Decode(&versionMap); err != nil {
+		return VersionInfo{}, err
+	}
+
+	return versionMap[Channel], nil
+}

internal/updater/updater_test.go

@@ -0,0 +1,336 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package updater
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"io"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/Masterminds/semver/v3"
+	"github.com/ProtonMail/proton-bridge/pkg/pmapi"
+	"github.com/ProtonMail/proton-bridge/pkg/pmapi/mocks"
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestWatch(t *testing.T) {
+	c := gomock.NewController(t)
+	defer c.Finish()
+
+	client := mocks.NewMockClient(c)
+
+	updater := newTestUpdater(client, "1.4.0")
+
+	versionMap := VersionMap{
+		"live": VersionInfo{
+			Version: semver.MustParse("1.5.0"),
+			MinAuto: semver.MustParse("1.4.0"),
+			Package: "https://protonmail.com/download/bridge/update_1.5.0_linux.tgz",
+			Rollout: 1.0,
+		},
+	}
+
+	client.EXPECT().DownloadAndVerify(
+		updater.getVersionFileURL(),
+		updater.getVersionFileURL()+".sig",
+		gomock.Any(),
+	).Return(bytes.NewReader(mustMarshal(t, versionMap)), nil)
+
+	client.EXPECT().Logout()
+
+	updateCh := make(chan VersionInfo)
+
+	defer updater.Watch(
+		time.Minute,
+		func(update VersionInfo) error {
+			updateCh <- update
+			return nil
+		},
+		func(err error) {
+			t.Fatal(err)
+		},
+	)()
+
+	assert.Equal(t, semver.MustParse("1.5.0"), (<-updateCh).Version)
+}
+
+func TestWatchIgnoresCurrentVersion(t *testing.T) {
+	c := gomock.NewController(t)
+	defer c.Finish()
+
+	client := mocks.NewMockClient(c)
+
+	updater := newTestUpdater(client, "1.5.0")
+
+	versionMap := VersionMap{
+		"live": VersionInfo{
+			Version: semver.MustParse("1.5.0"),
+			MinAuto: semver.MustParse("1.4.0"),
+			Package: "https://protonmail.com/download/bridge/update_1.5.0_linux.tgz",
+			Rollout: 1.0,
+		},
+	}
+
+	client.EXPECT().DownloadAndVerify(
+		updater.getVersionFileURL(),
+		updater.getVersionFileURL()+".sig",
+		gomock.Any(),
+	).Return(bytes.NewReader(mustMarshal(t, versionMap)), nil)
+
+	client.EXPECT().Logout()
+
+	updateCh := make(chan VersionInfo)
+
+	defer updater.Watch(
+		time.Minute,
+		func(update VersionInfo) error {
+			updateCh <- update
+			return nil
+		},
+		func(err error) {
+			t.Fatal(err)
+		},
+	)()
+
+	select {
+	case <-updateCh:
+		t.Fatal("We shouldn't update because we are already up to date")
+	case <-time.After(1500 * time.Millisecond):
+	}
+}
+
+func TestWatchIgnoresVerionsThatRequireManualUpdate(t *testing.T) {
+	c := gomock.NewController(t)
+	defer c.Finish()
+
+	client := mocks.NewMockClient(c)
+
+	updater := newTestUpdater(client, "1.4.0")
+
+	versionMap := VersionMap{
+		"live": VersionInfo{
+			Version: semver.MustParse("1.5.0"),
+			MinAuto: semver.MustParse("1.5.0"),
+			Package: "https://protonmail.com/download/bridge/update_1.5.0_linux.tgz",
+			Rollout: 1.0,
+		},
+	}
+
+	client.EXPECT().DownloadAndVerify(
+		updater.getVersionFileURL(),
+		updater.getVersionFileURL()+".sig",
+		gomock.Any(),
+	).Return(bytes.NewReader(mustMarshal(t, versionMap)), nil)
+
+	client.EXPECT().Logout()
+
+	updateCh := make(chan VersionInfo)
+
+	defer updater.Watch(
+		time.Minute,
+		func(update VersionInfo) error {
+			updateCh <- update
+			return nil
+		},
+		func(err error) {
+			t.Fatal(err)
+		},
+	)()
+
+	select {
+	case <-updateCh:
+		t.Fatal("We shouldn't update because this version requires a manual update")
+	case <-time.After(1500 * time.Millisecond):
+	}
+}
+
+func TestWatchBadSignature(t *testing.T) {
+	c := gomock.NewController(t)
+	defer c.Finish()
+
+	client := mocks.NewMockClient(c)
+
+	updater := newTestUpdater(client, "1.4.0")
+
+	client.EXPECT().DownloadAndVerify(
+		updater.getVersionFileURL(),
+		updater.getVersionFileURL()+".sig",
+		gomock.Any(),
+	).Return(nil, errors.New("bad signature"))
+
+	client.EXPECT().Logout()
+
+	updateCh := make(chan VersionInfo)
+	errorsCh := make(chan error)
+
+	defer updater.Watch(
+		time.Minute,
+		func(update VersionInfo) error {
+			updateCh <- update
+			return nil
+		},
+		func(err error) {
+			errorsCh <- err
+		},
+	)()
+
+	assert.Error(t, <-errorsCh)
+}
+
+func TestInstallUpdate(t *testing.T) {
+	c := gomock.NewController(t)
+	defer c.Finish()
+
+	client := mocks.NewMockClient(c)
+
+	updater := newTestUpdater(client, "1.4.0")
+
+	latestVersion := VersionInfo{
+		Version: semver.MustParse("1.5.0"),
+		MinAuto: semver.MustParse("1.4.0"),
+		Package: "https://protonmail.com/download/bridge/update_1.5.0_linux.tgz",
+		Rollout: 1.0,
+	}
+
+	client.EXPECT().DownloadAndVerify(
+		latestVersion.Package,
+		latestVersion.Package+".sig",
+		gomock.Any(),
+	).Return(bytes.NewReader([]byte("tgz_data_here")), nil)
+
+	client.EXPECT().Logout()
+
+	assert.NoError(t, updater.InstallUpdate(latestVersion))
+}
+
+func TestInstallUpdateBadSignature(t *testing.T) {
+	c := gomock.NewController(t)
+	defer c.Finish()
+
+	client := mocks.NewMockClient(c)
+
+	updater := newTestUpdater(client, "1.4.0")
+
+	latestVersion := VersionInfo{
+		Version: semver.MustParse("1.5.0"),
+		MinAuto: semver.MustParse("1.4.0"),
+		Package: "https://protonmail.com/download/bridge/update_1.5.0_linux.tgz",
+		Rollout: 1.0,
+	}
+
+	client.EXPECT().DownloadAndVerify(
+		latestVersion.Package,
+		latestVersion.Package+".sig",
+		gomock.Any(),
+	).Return(nil, errors.New("bad signature"))
+
+	client.EXPECT().Logout()
+
+	assert.Error(t, updater.InstallUpdate(latestVersion))
+}
+
+func TestInstallUpdateAlreadyOngoing(t *testing.T) {
+	c := gomock.NewController(t)
+	defer c.Finish()
+
+	client := mocks.NewMockClient(c)
+
+	updater := newTestUpdater(client, "1.4.0")
+
+	updater.installer = &fakeInstaller{delay: 2 * time.Second}
+
+	latestVersion := VersionInfo{
+		Version: semver.MustParse("1.5.0"),
+		MinAuto: semver.MustParse("1.4.0"),
+		Package: "https://protonmail.com/download/bridge/update_1.5.0_linux.tgz",
+		Rollout: 1.0,
+	}
+
+	client.EXPECT().DownloadAndVerify(
+		latestVersion.Package,
+		latestVersion.Package+".sig",
+		gomock.Any(),
+	).Return(bytes.NewReader([]byte("tgz_data_here")), nil)
+
+	client.EXPECT().Logout()
+
+	wg := &sync.WaitGroup{}
+
+	wg.Add(1)
+	go func() {
+		assert.NoError(t, updater.InstallUpdate(latestVersion))
+		wg.Done()
+	}()
+
+	// Wait for the installation to begin.
+	time.Sleep(time.Second)
+
+	err := updater.InstallUpdate(latestVersion)
+	if assert.Error(t, err) {
+		assert.Equal(t, ErrOperationOngoing, err)
+	}
+
+	wg.Wait()
+}
+
+func newTestUpdater(client *mocks.MockClient, curVer string) *Updater {
+	return New(
+		&fakeClientProvider{client: client},
+		&fakeInstaller{},
+		nil,
+		semver.MustParse(curVer),
+		"bridge", "linux",
+		0.5,
+	)
+}
+
+type fakeClientProvider struct {
+	client *mocks.MockClient
+}
+
+func (p *fakeClientProvider) GetAnonymousClient() pmapi.Client {
+	return p.client
+}
+
+type fakeInstaller struct {
+	bad   bool
+	delay time.Duration
+}
+
+func (i *fakeInstaller) InstallUpdate(version *semver.Version, r io.Reader) error {
+	if i.bad {
+		return errors.New("bad install")
+	}
+
+	time.Sleep(i.delay)
+
+	return nil
+}
+
+func mustMarshal(t *testing.T, v interface{}) []byte {
+	b, err := json.Marshal(v)
+	require.NoError(t, err)
+
+	return b
+}

internal/updater/version.go

@@ -0,0 +1,85 @@
+// Copyright (c) 2020 Proton Technologies AG
+//
+// This file is part of ProtonMail Bridge.
+//
+// ProtonMail Bridge is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// ProtonMail Bridge is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
+
+package updater
+
+import (
+	"fmt"
+
+	"github.com/Masterminds/semver/v3"
+)
+
+// VersionInfo is information about one version of the app.
+type VersionInfo struct {
+	// Version is the semantic version of the release.
+	Version *semver.Version
+
+	// MinAuto is the earliest version that is able to autoupdate to this version.
+	// Apps older than this version must run the manual installer and cannot autoupdate.
+	MinAuto *semver.Version
+
+	// Package is the location of the update package.
+	Package string
+
+	// Installers are the locations of installer files (for manual installation).
+	Installers []string
+
+	// Landing is the address of the app landing page on protonmail.com.
+	Landing string
+
+	// Rollout is the current progress of the rollout of this release.
+	Rollout float64
+}
+
+// VersionMap represents the structure of the version.json file.
+// It looks like this:
+// {
+//   "live": {
+//     "Version": "2.3.4",
+//     "Package": "https://protonmail.com/.../bridge_2.3.4_linux.tgz",
+//     "Installers": [
+//       "https://protonmail.com/.../something.deb",
+//       "https://protonmail.com/.../something.rpm",
+//       "https://protonmail.com/.../PKGBUILD"
+//     ],
+//     "Landing "https://protonmail.com/bridge",
+//     "Rollout": 0.5
+//   },
+//   "beta": {
+//     "Version": "2.4.0-beta",
+//     "Package": "https://protonmail.com/.../bridge_2.4.0-beta_linux.tgz",
+//     "Installers": [
+//       "https://protonmail.com/.../something.deb",
+//       "https://protonmail.com/.../something.rpm",
+//       "https://protonmail.com/.../PKGBUILD"
+//     ],
+//     "Landing "https://protonmail.com/bridge",
+//     "Rollout": 0.5
+//   },
+//   "...": {
+//     ...
+//   }
+// }
+type VersionMap map[string]VersionInfo
+
+// getVersionFileURL returns the URL of the version file.
+// For example:
+//  - https://protonmail.com/download/bridge/version_linux.json
+//  - https://protonmail.com/download/ie/version_linux.json
+func (u *Updater) getVersionFileURL() string {
+	return fmt.Sprintf("%v/%v/version_%v.json", Host, u.updateURLName, u.platform)
+}

internal/updates/compare_versions.go

@@ -1,102 +0,0 @@
-// Copyright (c) 2021 Proton Technologies AG
-//
-// This file is part of ProtonMail Bridge.
-//
-// ProtonMail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// ProtonMail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package updates
-
-import (
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-var nonVersionChars = regexp.MustCompile(`([^0-9.]+)`) //nolint[gochecknoglobals]
-
-// sanitizeVersion returns only numbers and periods.
-func sanitizeVersion(version string) string {
-	return nonVersionChars.ReplaceAllString(version, "")
-}
-
-// Result can be false positive, but must not be false negative.
-// Assuming
-//  * dot separated integers format e.g. "A.B.C.…" where A,B,C,… are integers
-//  * `1.1` == `1.1.0` (i.e. first is not newer)
-//  * `1.1.1` > `1.1` (i.e. first is newer)
-func isFirstVersionNewer(first, second string) (firstIsNewer bool, err error) {
-	first = sanitizeVersion(first)
-	second = sanitizeVersion(second)
-
-	firstIsNewer, err = false, nil
-	if first == second {
-		return
-	}
-
-	firstIsNewer = true
-	var firstArr, secondArr []int
-	if firstArr, err = versionStrToInts(first); err != nil {
-		return
-	}
-	if secondArr, err = versionStrToInts(second); err != nil {
-		return
-	}
-
-	verLength := max(len(firstArr), len(secondArr))
-	firstArr = appendZeros(firstArr, verLength)
-	secondArr = appendZeros(secondArr, verLength)
-
-	for i := 0; i < verLength; i++ {
-		if firstArr[i] == secondArr[i] {
-			continue
-		}
-		return firstArr[i] > secondArr[i], nil
-	}
-	return false, nil
-}
-
-func versionStrToInts(version string) (intArr []int, err error) {
-	strArr := strings.Split(version, ".")
-	intArr = make([]int, len(strArr))
-	for index, item := range strArr {
-		if item == "" {
-			intArr[index] = 0
-			continue
-		}
-		intArr[index], err = strconv.Atoi(item)
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-func appendZeros(ints []int, newsize int) []int {
-	size := len(ints)
-	if size >= newsize {
-		return ints
-	}
-	zeros := make([]int, newsize-size)
-	return append(ints, zeros...)
-}
-
-func max(ints ...int) (max int) {
-	max = ints[0]
-	for _, a := range ints {
-		if max < a {
-			max = a
-		}
-	}
-	return
-}

internal/updates/compare_versions_test.go

@@ -1,78 +0,0 @@
-// Copyright (c) 2021 Proton Technologies AG
-//
-// This file is part of ProtonMail Bridge.
-//
-// ProtonMail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// ProtonMail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package updates
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-type testDataValues struct {
-	expectErr, expectedNewer bool
-	first, second            string
-}
-type testDataList []testDataValues
-
-func (tdl *testDataList) add(err, newer bool, first, second string) { //nolint[unparam]
-	*tdl = append(*tdl, testDataValues{err, newer, first, second})
-}
-
-func (tdl *testDataList) addFirstIsNewer(first, second string) {
-	tdl.add(false, true, first, second)
-	tdl.add(false, false, second, first)
-}
-
-func TestCompareVersion(t *testing.T) {
-	testData := testDataList{}
-	// same is never newer
-	testData.add(false, false, "1.1.1", "1.1.1")
-	testData.add(false, false, "1.1.0", "1.1")
-	testData.add(false, false, "1.0.0", "1")
-	testData.add(false, false, ".1.1", "0.1.1")
-	testData.add(false, false, "0.1.1", ".1.1")
-
-	testData.addFirstIsNewer("1.1.10", "1.1.1")
-	testData.addFirstIsNewer("1.10.1", "1.1.1")
-	testData.addFirstIsNewer("10.1.1", "1.1.1")
-
-	testData.addFirstIsNewer("1.1.1", "0.1.1")
-	testData.addFirstIsNewer("1.1.1", "1.0.1")
-	testData.addFirstIsNewer("1.1.1", "1.1.0")
-
-	testData.addFirstIsNewer("1.1.1", "1")
-	testData.addFirstIsNewer("1.1.1", "1.1")
-	testData.addFirstIsNewer("1.1.1.1", "1.1.1")
-
-	testData.addFirstIsNewer("1.1.1 beta", "1.1.0")
-	testData.addFirstIsNewer("1z.1z.1z", "1.1.0")
-	testData.addFirstIsNewer("1a.1b.1c", "1.1.0")
-
-	for _, td := range testData {
-		t.Log(td)
-		isNewer, err := isFirstVersionNewer(td.first, td.second)
-		if td.expectErr {
-			require.True(t, err != nil, "expected error but got nil for %#v", td)
-			require.True(t, true == isNewer, "error expected but first is not newer for %#v", td)
-			continue
-		}
-
-		require.True(t, err == nil, "expected no error but have %v for %#v", err, td)
-		require.True(t, isNewer == td.expectedNewer, "expected %v but have %v for %#v", td.expectedNewer, isNewer, err, td)
-	}
-}

internal/updates/downloader.go

@@ -1,131 +0,0 @@
-// Copyright (c) 2021 Proton Technologies AG
-//
-// This file is part of ProtonMail Bridge.
-//
-// ProtonMail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// ProtonMail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package updates
-
-import (
-	"errors"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strconv"
-
-	"github.com/ProtonMail/proton-bridge/pkg/dialer"
-)
-
-func mkdirAllClear(path string) error {
-	if err := os.RemoveAll(path); err != nil {
-		return err
-	}
-	return os.MkdirAll(path, 0750)
-}
-
-func downloadToBytes(path string) (out []byte, err error) {
-	var (
-		client   *http.Client
-		response *http.Response
-	)
-	client = dialer.DialTimeoutClient()
-	log.WithField("path", path).Trace("Downloading")
-
-	response, err = client.Get(path)
-	if err != nil {
-		return
-	}
-	out, err = ioutil.ReadAll(response.Body)
-	_ = response.Body.Close()
-	if response.StatusCode < http.StatusOK || http.StatusIMUsed < response.StatusCode {
-		err = errors.New(path + " " + response.Status)
-	}
-	return
-}
-
-func downloadWithProgress(status *Progress, sourceURL, targetPath string) (err error) {
-	targetFile, err := os.Create(targetPath)
-	if err != nil {
-		log.Warnf("Cannot create update file %s: %v", targetPath, err)
-		return
-	}
-	defer targetFile.Close() //nolint[errcheck]
-
-	var (
-		client   *http.Client
-		response *http.Response
-	)
-	client = dialer.DialTimeoutClient()
-	response, err = client.Get(sourceURL)
-	if err != nil {
-		return
-	}
-	defer response.Body.Close() //nolint[errcheck]
-
-	contentLength, _ := strconv.ParseUint(response.Header.Get("Content-Length"), 10, 64)
-
-	wc := WriteCounter{
-		Status: status,
-		Target: targetFile,
-		Size:   contentLength,
-	}
-
-	err = wc.ReadAll(response.Body)
-	return
-}
-
-func downloadWithSignature(status *Progress, sourceURL, targetDir string) (localPath string, err error) {
-	localPath = filepath.Join(targetDir, filepath.Base(sourceURL))
-
-	if err = downloadWithProgress(nil, sourceURL+sigExtension, localPath+sigExtension); err != nil {
-		return
-	}
-
-	if err = downloadWithProgress(status, sourceURL, localPath); err != nil {
-		return
-	}
-	return
-}
-
-type WriteCounter struct {
-	Status                   *Progress
-	Target                   io.Writer
-	processed, Size, counter uint64
-}
-
-func (s *WriteCounter) ReadAll(source io.Reader) (err error) {
-	s.counter = uint64(0)
-	if s.Target == nil {
-		return errors.New("can not read all, target unset")
-	}
-	if source == nil {
-		return errors.New("can not read all, source unset")
-	}
-	_, err = io.Copy(s.Target, io.TeeReader(source, s))
-	return
-}
-
-func (s *WriteCounter) Write(p []byte) (int, error) {
-	if s.Status != nil && s.Size != 0 {
-		s.processed += uint64(len(p))
-		fraction := float32(s.processed) / float32(s.Size)
-		if s.counter%uint64(100) == 0 || fraction == 1. {
-			s.Status.UpdateProcessed(fraction)
-		}
-	}
-	s.counter++
-	return len(p), nil
-}

internal/updates/signature.go

@@ -1,108 +0,0 @@
-// Copyright (c) 2021 Proton Technologies AG
-//
-// This file is part of ProtonMail Bridge.
-//
-// ProtonMail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// ProtonMail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package updates
-
-import (
-	"bytes"
-	"encoding/hex"
-	"errors"
-	"io"
-	"os"
-	"os/exec"
-	"runtime"
-
-	"golang.org/x/crypto/openpgp"
-)
-
-// gpg --export D51E64D3E63EDC3EEF7864CEE2C75D68E6234B07 | xxd -p | tr -d '\n' | xclip
-const (
-	keyID     = "D51E64D3E63EDC3EEF7864CEE2C75D68E6234B07"
-	pubkeyHex = "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"
-)
-
-var (
-	pubkeyRing = openpgp.EntityList{} //nolint[gochecknoglobals]
-)
-
-func singAndVerify(pathToFile string) (err error) {
-	err = signFile(pathToFile)
-	if err != nil {
-		err = verifyFile(pathToFile)
-	}
-	return
-}
-
-func signFile(pathToFile string) (err error) {
-	if runtime.GOOS != "linux" { //nolint[goconst]
-		return errors.New("tar not implemented only for linux")
-	}
-	// assuming gpg detach-sign creates file with suffix .sig by default.
-	// Lstat does not follow the link i.e. only link is deleted (not link target).
-	if _, err := os.Lstat(pathToFile + sigExtension); !os.IsNotExist(err) {
-		_ = os.Remove(pathToFile + sigExtension)
-	}
-	cmd := exec.Command("gpg", "--local-user", keyID, "--detach-sign", pathToFile) //nolint[gosec]
-	return cmd.Run()
-}
-
-func verifyFile(pathToFile string) error {
-	fileReader, err := os.Open(pathToFile) //nolint[gosec]
-	if err != nil {
-		return err
-	}
-	defer fileReader.Close() //nolint[errcheck]
-
-	signatureReader, err := os.Open(pathToFile + sigExtension) //nolint[gosec]
-	if err != nil {
-		return err
-	}
-	defer signatureReader.Close() //nolint[errcheck]
-
-	return verifyBytes(fileReader, signatureReader)
-}
-
-func verifyBytes(fileReader, signatureReader io.Reader) (err error) {
-	if _, err = getPubKey(); err != nil {
-		return err
-	}
-
-	_, err = openpgp.CheckDetachedSignature(pubkeyRing, fileReader, signatureReader, nil)
-	/*
-		if err != nil {
-			return err
-		}
-
-		if signer == nil || signer.PrimaryKey.KeyId != keyID {
-			return errors.New("Signer with wrong key ID")
-		}
-	*/
-	return
-}
-
-// from opengpg/read_test.go
-func getPubKey() (el openpgp.EntityList, err error) {
-	if pubkeyRing != nil && len(pubkeyRing) != 0 {
-		return pubkeyRing, nil
-	}
-	data, err := hex.DecodeString(pubkeyHex)
-	if err != nil {
-		return
-	}
-	pubkeyRing, err = openpgp.ReadKeyRing(bytes.NewBuffer(data))
-	return pubkeyRing, err
-}

internal/updates/tar.go

@@ -1,126 +0,0 @@
-// Copyright (c) 2021 Proton Technologies AG
-//
-// This file is part of ProtonMail Bridge.
-//
-// ProtonMail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// ProtonMail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package updates
-
-import (
-	"archive/tar"
-	"compress/gzip"
-	"errors"
-	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-
-	"github.com/sirupsen/logrus"
-)
-
-func createTar(tarPath, sourcePath string) error { //nolint[unused]
-	if runtime.GOOS != "linux" {
-		return errors.New("tar not implemented only for linux")
-	}
-	// Check whether it exists and is a directory.
-	if _, err := os.Lstat(sourcePath); err != nil {
-		return err
-	}
-
-	absPath, err := filepath.Abs(tarPath)
-	if err != nil {
-		return err
-	}
-
-	cmd := exec.Command("tar", "-zvcf", absPath, filepath.Base(sourcePath)) //nolint[gosec]
-	cmd.Dir = filepath.Dir(sourcePath)
-	cmd.Stderr = log.WriterLevel(logrus.ErrorLevel)
-	cmd.Stdout = log.WriterLevel(logrus.InfoLevel)
-	return cmd.Run()
-}
-
-func untarToDir(tarPath, targetDir string, status *Progress) error { //nolint[funlen]
-	// Check whether it exists and is a directory.
-	if ls, err := os.Lstat(targetDir); err == nil {
-		if !ls.IsDir() {
-			return errors.New("not a dir")
-		}
-	} else {
-		return err
-	}
-
-	tgzReader, err := os.Open(tarPath) //nolint[gosec]
-	if err != nil {
-		return err
-	}
-	defer tgzReader.Close() //nolint[errcheck]
-
-	size := uint64(0)
-	if info, err := tgzReader.Stat(); err == nil {
-		size = uint64(info.Size())
-	}
-
-	wc := &WriteCounter{
-		Status: status,
-		Size:   size,
-	}
-
-	tarReader, err := gzip.NewReader(io.TeeReader(tgzReader, wc))
-	if err != nil {
-		return err
-	}
-
-	fileReader := tar.NewReader(tarReader)
-	for {
-		header, err := fileReader.Next()
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return err
-		}
-		if header == nil {
-			continue
-		}
-
-		targetFile := filepath.Join(targetDir, header.Name)
-		info := header.FileInfo()
-
-		// Create symlink.
-		if header.Typeflag == tar.TypeSymlink {
-			if header.Linkname == "" {
-				return errors.New("missing linkname")
-			}
-			if err := os.Symlink(header.Linkname, targetFile); err != nil {
-				return err
-			}
-			continue
-		}
-
-		// Handle case that it is a directory.
-		if info.IsDir() {
-			if err := os.MkdirAll(targetFile, info.Mode()); err != nil {
-				return err
-			}
-			continue
-		}
-
-		// Handle case that it is a regular file.
-		if err := copyToFileTruncate(fileReader, targetFile, info.Mode()); err != nil {
-			return err
-		}
-	}
-	return nil
-}

internal/updates/testdata/current_version_linux.json

@@ -1 +0,0 @@
-{"Version":"1.1.6","ReleaseDate":"10 Jul 19 11:02 +0200","ReleaseNotes":"• Necessary updates reflecting API changes\n• Report wrongly formated messages\n","ReleaseFixedBugs":"• Fixed verification for contacts signed by older or missing key\n• Outlook always shows attachment icon\n","FixedBugs":["• Fixed verification for contacts signed by older or missing key","• Outlook always shows attachment icon",""],"URL":"https://protonmail.com/download/Bridge-Installer.sh","LandingPage":"https://protonmail.com/bridge/download","UpdateFile":"https://protonmail.com/download/bridge_upgrade_linux.tgz","InstallerFile":"https://protonmail.com/download/Bridge-Installer.sh","DebFile":"https://protonmail.com/download/protonmail-bridge_1.1.6-1_amd64.deb","RpmFile":"https://protonmail.com/download/protonmail-bridge-1.1.6-1.x86_64.rpm","PkgFile":"https://protonmail.com/download/PKGBUILD"}

internal/updates/updates.go

@@ -1,349 +0,0 @@
-// Copyright (c) 2021 Proton Technologies AG
-//
-// This file is part of ProtonMail Bridge.
-//
-// ProtonMail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// ProtonMail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package updates
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"io/ioutil"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strings"
-
-	"github.com/ProtonMail/proton-bridge/internal/bridge"
-	"github.com/ProtonMail/proton-bridge/internal/importexport"
-	"github.com/ProtonMail/proton-bridge/pkg/constants"
-	"github.com/kardianos/osext"
-	"github.com/sirupsen/logrus"
-)
-
-const (
-	sigExtension = ".sig"
-)
-
-var (
-	Host         = "https://protonmail.com" //nolint[gochecknoglobals]
-	DownloadPath = "download"               //nolint[gochecknoglobals]
-
-	// BuildType specifies type of build (e.g. QA or beta).
-	BuildType = "" //nolint[gochecknoglobals]
-)
-
-var (
-	log = logrus.WithField("pkg", "bridgeUtils/updates") //nolint[gochecknoglobals]
-
-	ErrDownloadFailed     = errors.New("error happened during download") //nolint[gochecknoglobals]
-	ErrUpdateVerifyFailed = errors.New("cannot verify signature")        //nolint[gochecknoglobals]
-)
-
-type Updates struct {
-	version             string
-	revision            string
-	buildTime           string
-	releaseNotes        string
-	releaseFixedBugs    string
-	updateTempDir       string
-	landingPagePath     string       // Based on Host/; default landing page for download.
-	winInstallerFile    string       // File for initial install or manual reinstall for windows
-	macInstallerFile    string       // File for initial install or manual reinstall for mac
-	linInstallerFile    string       // File for initial install or manual reinstall for linux
-	versionFileBaseName string       // Text file containing information about current file. per goos [_linux,_darwin,_windows].json (have .sig file).
-	updateFileBaseName  string       // File for automatic update. per goos [_linux,_darwin,_windows].tgz  (have .sig file).
-	linuxFileBaseName   string       // Prefix of linux package names.
-	macAppBundleName    string       // Name of Mac app file in the bundle for update procedure.
-	cachedNewerVersion  *VersionInfo // To have info about latest version even when the internet connection drops.
-}
-
-// NewBridge inits Updates struct for bridge.
-func NewBridge(updateTempDir string) *Updates {
-	return &Updates{
-		version:             constants.Version,
-		revision:            constants.Revision,
-		buildTime:           constants.BuildTime,
-		releaseNotes:        bridge.ReleaseNotes,
-		releaseFixedBugs:    bridge.ReleaseFixedBugs,
-		updateTempDir:       updateTempDir,
-		landingPagePath:     "bridge/download",
-		winInstallerFile:    "Bridge-Installer.exe",
-		macInstallerFile:    "Bridge-Installer.dmg",
-		linInstallerFile:    "Bridge-Installer.sh",
-		versionFileBaseName: "current_version",
-		updateFileBaseName:  "bridge_upgrade",
-		linuxFileBaseName:   "protonmail-bridge",
-		macAppBundleName:    "ProtonMail Bridge.app",
-	}
-}
-
-// NewImportExport inits Updates struct for import-export.
-func NewImportExport(updateTempDir string) *Updates {
-	return &Updates{
-		version:             constants.Version,
-		revision:            constants.Revision,
-		buildTime:           constants.BuildTime,
-		releaseNotes:        importexport.ReleaseNotes,
-		releaseFixedBugs:    importexport.ReleaseFixedBugs,
-		updateTempDir:       updateTempDir,
-		landingPagePath:     "import-export",
-		winInstallerFile:    "ie/Import-Export-app-installer.exe",
-		macInstallerFile:    "ie/Import-Export-app.dmg",
-		linInstallerFile:    "ie/Import-Export-app-installer.sh",
-		versionFileBaseName: "current_version_ie",
-		updateFileBaseName:  "ie/ie_upgrade",
-		linuxFileBaseName:   "ie/protonmail-import-export-app",
-		macAppBundleName:    "ProtonMail Import-Export app.app",
-	}
-}
-
-func (u *Updates) CreateJSONAndSign(deployDir, goos string) error {
-	versionInfo := u.getLocalVersion(goos)
-	versionInfo.Version = sanitizeVersion(versionInfo.Version)
-
-	versionFileName := filepath.Base(u.versionFileURL(goos))
-	versionFilePath := filepath.Join(deployDir, versionFileName)
-
-	txt, err := json.Marshal(versionInfo)
-	if err != nil {
-		return err
-	}
-
-	if err = ioutil.WriteFile(versionFilePath, txt, 0600); err != nil {
-		return err
-	}
-
-	if err := singAndVerify(versionFilePath); err != nil {
-		return err
-	}
-
-	updateFileName := filepath.Base(versionInfo.UpdateFile)
-	updateFilePath := filepath.Join(deployDir, updateFileName)
-	if err := singAndVerify(updateFilePath); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (u *Updates) CheckIsUpToDate() (isUpToDate bool, latestVersion VersionInfo, err error) {
-	localVersion := u.GetLocalVersion()
-	latestVersion, err = u.getLatestVersion()
-	if err != nil {
-		return
-	}
-
-	localIsOld, err := isFirstVersionNewer(latestVersion.Version, localVersion.Version)
-	return !localIsOld, latestVersion, err
-}
-
-func (u *Updates) GetDownloadLink() string {
-	latestVersion, err := u.getLatestVersion()
-	if err != nil || latestVersion.InstallerFile == "" {
-		localVersion := u.GetLocalVersion()
-		return localVersion.GetDownloadLink()
-	}
-	return latestVersion.GetDownloadLink()
-}
-
-func (u *Updates) GetLocalVersion() VersionInfo {
-	return u.getLocalVersion(runtime.GOOS)
-}
-
-func (u *Updates) getLocalVersion(goos string) VersionInfo {
-	version := u.version
-	if BuildType != "" {
-		version += " " + BuildType
-	}
-
-	versionInfo := VersionInfo{
-		Version:          version,
-		Revision:         u.revision,
-		ReleaseDate:      u.buildTime,
-		ReleaseNotes:     u.releaseNotes,
-		ReleaseFixedBugs: u.releaseFixedBugs,
-		FixedBugs:        strings.Split(u.releaseFixedBugs, "\n"),
-		URL:              u.installerFileURL(goos),
-
-		LandingPage:   u.landingPageURL(),
-		UpdateFile:    u.updateFileURL(goos),
-		InstallerFile: u.installerFileURL(goos),
-	}
-
-	if goos == "linux" {
-		pkgName := u.linuxFileBaseName
-		pkgRel := "1"
-		pkgBaseFile := strings.Join([]string{Host, DownloadPath, pkgName}, "/")
-
-		pkgBasePath := DownloadPath + "/" + pkgName // add at least one dir
-		pkgBasePath = filepath.Dir(pkgBasePath)     // keep only last dir
-		pkgBasePath = Host + "/" + pkgBasePath      // add host in the end to not strip off double slash in URL
-
-		versionInfo.DebFile = pkgBaseFile + "_" + u.version + "-" + pkgRel + "_amd64.deb"
-		versionInfo.RpmFile = pkgBaseFile + "-" + u.version + "-" + pkgRel + ".x86_64.rpm"
-		versionInfo.PkgFile = strings.Join([]string{pkgBasePath, "PKGBUILD"}, "/")
-	}
-
-	return versionInfo
-}
-
-func (u *Updates) getLatestVersion() (latestVersion VersionInfo, err error) {
-	version, err := downloadToBytes(u.versionFileURL(runtime.GOOS))
-	if err != nil {
-		if u.cachedNewerVersion != nil {
-			return *u.cachedNewerVersion, nil
-		}
-		return
-	}
-
-	signature, err := downloadToBytes(u.signatureFileURL(runtime.GOOS))
-	if err != nil {
-		if u.cachedNewerVersion != nil {
-			return *u.cachedNewerVersion, nil
-		}
-		return
-	}
-
-	if err = verifyBytes(bytes.NewReader(version), bytes.NewReader(signature)); err != nil {
-		return
-	}
-
-	if err = json.NewDecoder(bytes.NewReader(version)).Decode(&latestVersion); err != nil {
-		return
-	}
-	if localIsOld, _ := isFirstVersionNewer(latestVersion.Version, u.version); localIsOld {
-		u.cachedNewerVersion = &latestVersion
-	}
-	return
-}
-
-func (u *Updates) landingPageURL() string {
-	return strings.Join([]string{Host, u.landingPagePath}, "/")
-}
-
-func (u *Updates) signatureFileURL(goos string) string {
-	return u.versionFileURL(goos) + sigExtension
-}
-
-func (u *Updates) versionFileURL(goos string) string {
-	return strings.Join([]string{Host, DownloadPath, u.versionFileBaseName + "_" + goos + ".json"}, "/")
-}
-
-func (u *Updates) installerFileURL(goos string) string {
-	installerFile := u.linInstallerFile
-	switch goos {
-	case "darwin": //nolint[goconst]
-		installerFile = u.macInstallerFile
-	case "windows": //nolint[goconst]
-		installerFile = u.winInstallerFile
-	}
-	return strings.Join([]string{Host, DownloadPath, installerFile}, "/")
-}
-
-func (u *Updates) updateFileURL(goos string) string {
-	return strings.Join([]string{Host, DownloadPath, u.updateFileBaseName + "_" + goos + ".tgz"}, "/")
-}
-
-func (u *Updates) StartUpgrade(currentStatus chan<- Progress) { // nolint[funlen]
-	status := &Progress{channel: currentStatus}
-	defer status.Update()
-
-	// Get latest version.
-	var verInfo VersionInfo
-	status.UpdateDescription(InfoCurrentVersion)
-	if verInfo, status.Err = u.getLatestVersion(); status.Err != nil {
-		return
-	}
-
-	if verInfo.UpdateFile == "" {
-		log.Warn("Empty update URL. Update manually.")
-		status.Err = ErrDownloadFailed
-		return
-	}
-
-	// Download.
-	status.UpdateDescription(InfoDownloading)
-	if status.Err = mkdirAllClear(u.updateTempDir); status.Err != nil {
-		return
-	}
-	var updateTar string
-	updateTar, status.Err = downloadWithSignature(
-		status,
-		verInfo.UpdateFile,
-		u.updateTempDir,
-	)
-	if status.Err != nil {
-		return
-	}
-
-	// Check signature.
-	status.UpdateDescription(InfoVerifying)
-	status.Err = verifyFile(updateTar)
-	if status.Err != nil {
-		log.Warnf("Cannot verify update file %s: %v", updateTar, status.Err)
-		status.Err = ErrUpdateVerifyFailed
-		return
-	}
-
-	// Untar.
-	status.UpdateDescription(InfoUnpacking)
-	status.Err = untarToDir(updateTar, u.updateTempDir, status)
-	if status.Err != nil {
-		return
-	}
-
-	// Run upgrade (OS specific).
-	status.UpdateDescription(InfoUpgrading)
-	switch runtime.GOOS {
-	case "windows": //nolint[goconst]
-		// Cannot use filepath.Base on windows it has different delimiter
-		split := strings.Split(u.winInstallerFile, "/")
-		installerFile := split[len(split)-1]
-		cmd := exec.Command("./" + installerFile) // nolint[gosec]
-		cmd.Dir = u.updateTempDir
-		status.Err = cmd.Start()
-	case "darwin": //nolint[goconst]
-		// current path is better then appDir = filepath.Join("/Applications")
-		var exePath string
-		exePath, status.Err = osext.Executable()
-		if status.Err != nil {
-			return
-		}
-		localPath := filepath.Dir(exePath)  // Macos
-		localPath = filepath.Dir(localPath) // Contents
-		localPath = filepath.Dir(localPath) // .app
-
-		updatePath := filepath.Join(u.updateTempDir, u.macAppBundleName)
-		log.WithField("local", localPath).
-			WithField("update", updatePath).
-			Info("Syncing folders..")
-		status.Err = syncFolders(localPath, updatePath)
-		if status.Err != nil {
-			log.WithField("from", localPath).
-				WithField("to", updatePath).
-				WithError(status.Err).
-				Error("Sync failed.")
-			return
-		}
-		status.UpdateDescription(InfoRestartApp)
-		return
-	default:
-		status.Err = errors.New("upgrade for " + runtime.GOOS + " not implemented")
-	}
-
-	status.UpdateDescription(InfoQuitApp)
-}

internal/updates/updates_test.go

@@ -1,184 +0,0 @@
-// Copyright (c) 2021 Proton Technologies AG
-//
-// This file is part of ProtonMail Bridge.
-//
-// ProtonMail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// ProtonMail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package updates
-
-import (
-	"io/ioutil"
-	"net/http"
-	"os"
-	"runtime"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-const testServerPort = "8999"
-
-var testUpdateDir string //nolint[gochecknoglobals]
-
-func TestMain(m *testing.M) {
-	setup()
-	code := m.Run()
-	shutdown()
-	os.Exit(code)
-}
-
-func setup() {
-	var err error
-	testUpdateDir, err = ioutil.TempDir("", "upgrade")
-	if err != nil {
-		panic(err)
-	}
-
-	Host = "http://localhost:" + testServerPort
-	go startServer()
-}
-
-func shutdown() {
-	_ = os.RemoveAll(testUpdateDir)
-}
-
-func startServer() {
-	http.HandleFunc("/download/current_version_linux.json", func(w http.ResponseWriter, r *http.Request) {
-		http.ServeFile(w, r, "./testdata/current_version_linux.json")
-	})
-	http.HandleFunc("/download/current_version_linux.json.sig", func(w http.ResponseWriter, r *http.Request) {
-		http.ServeFile(w, r, "./testdata/current_version_linux.json.sig")
-	})
-	http.HandleFunc("/download/current_version_darwin.json", func(w http.ResponseWriter, r *http.Request) {
-		http.ServeFile(w, r, "./testdata/current_version_linux.json")
-	})
-	http.HandleFunc("/download/current_version_darwin.json.sig", func(w http.ResponseWriter, r *http.Request) {
-		http.ServeFile(w, r, "./testdata/current_version_linux.json.sig")
-	})
-	panic(http.ListenAndServe(":"+testServerPort, nil))
-}
-
-func TestCheckBridgeIsUpToDate(t *testing.T) {
-	updates := newTestUpdates("1.1.6")
-	isUpToDate, _, err := updates.CheckIsUpToDate()
-	require.NoError(t, err)
-	require.True(t, isUpToDate, "Bridge should be up to date")
-}
-
-func TestCheckBridgeIsNotUpToDate(t *testing.T) {
-	updates := newTestUpdates("1.1.5")
-	isUpToDate, _, err := updates.CheckIsUpToDate()
-	require.NoError(t, err)
-	require.True(t, !isUpToDate, "Bridge should not be up to date")
-}
-
-func TestGetLocalVersion(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("skipping test because local version for windows is currently not supported by tests.")
-	}
-	updates := newTestUpdates("1")
-	expectedVersion := VersionInfo{
-		Version:          "1",
-		Revision:         "rev123",
-		ReleaseDate:      "42",
-		ReleaseNotes:     "• new feature",
-		ReleaseFixedBugs: "• fixed foo",
-		FixedBugs:        []string{"• fixed foo"},
-		URL:              Host + "/" + DownloadPath + "/Bridge-Installer.sh",
-
-		LandingPage:   Host + "/bridge/download",
-		UpdateFile:    Host + "/" + DownloadPath + "/bridge_upgrade_linux.tgz",
-		InstallerFile: Host + "/" + DownloadPath + "/Bridge-Installer.sh",
-
-		DebFile: Host + "/" + DownloadPath + "/protonmail-bridge_1-1_amd64.deb",
-		RpmFile: Host + "/" + DownloadPath + "/protonmail-bridge-1-1.x86_64.rpm",
-		PkgFile: Host + "/" + DownloadPath + "/PKGBUILD",
-	}
-	if runtime.GOOS == "darwin" {
-		expectedVersion.URL = Host + "/" + DownloadPath + "/Bridge-Installer.dmg"
-		expectedVersion.UpdateFile = Host + "/" + DownloadPath + "/bridge_upgrade_darwin.tgz"
-		expectedVersion.InstallerFile = expectedVersion.URL
-		expectedVersion.DebFile = ""
-		expectedVersion.RpmFile = ""
-		expectedVersion.PkgFile = ""
-	}
-	version := updates.GetLocalVersion()
-	require.Equal(t, expectedVersion, version)
-}
-
-func TestGetLatestVersion(t *testing.T) {
-	updates := newTestUpdates("1")
-	expectedVersion := VersionInfo{
-		Version:          "1.1.6",
-		Revision:         "",
-		ReleaseDate:      "10 Jul 19 11:02 +0200",
-		ReleaseNotes:     "• Necessary updates reflecting API changes\n• Report wrongly formated messages\n",
-		ReleaseFixedBugs: "• Fixed verification for contacts signed by older or missing key\n• Outlook always shows attachment icon\n",
-		FixedBugs: []string{
-			"• Fixed verification for contacts signed by older or missing key",
-			"• Outlook always shows attachment icon",
-			"",
-		},
-		URL: "https://protonmail.com/download/Bridge-Installer.sh",
-
-		LandingPage:   "https://protonmail.com/bridge/download",
-		UpdateFile:    "https://protonmail.com/download/bridge_upgrade_linux.tgz",
-		InstallerFile: "https://protonmail.com/download/Bridge-Installer.sh",
-
-		DebFile: "https://protonmail.com/download/protonmail-bridge_1.1.6-1_amd64.deb",
-		RpmFile: "https://protonmail.com/download/protonmail-bridge-1.1.6-1.x86_64.rpm",
-		PkgFile: "https://protonmail.com/download/PKGBUILD",
-	}
-	version, err := updates.getLatestVersion()
-	require.NoError(t, err)
-	require.Equal(t, expectedVersion, version)
-}
-
-func TestStartUpgrade(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping test in short mode.")
-	}
-	if runtime.GOOS != "windows" {
-		t.Skip("skipping test because only upgrading on windows is currently supported by tests.")
-	}
-
-	updates := newTestUpdates("1")
-	progress := make(chan Progress, 1)
-	done := make(chan error)
-
-	go func() {
-		for current := range progress {
-			log.Infof("progress descr: %d processed %f err %v", current.Description, current.Processed, current.Err)
-			if current.Err != nil {
-				done <- current.Err
-				break
-			}
-		}
-		done <- nil
-	}()
-
-	updates.StartUpgrade(progress)
-	close(progress)
-	require.NoError(t, <-done)
-}
-
-func newTestUpdates(version string) *Updates {
-	u := NewBridge(testUpdateDir)
-	u.version = version
-	u.revision = "rev123"
-	u.buildTime = "42"
-	u.releaseNotes = "• new feature"
-	u.releaseFixedBugs = "• fixed foo"
-	return u
-}

internal/updates/version_info.go

@@ -1,49 +0,0 @@
-// Copyright (c) 2021 Proton Technologies AG
-//
-// This file is part of ProtonMail Bridge.
-//
-// ProtonMail Bridge is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// ProtonMail Bridge is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with ProtonMail Bridge.  If not, see <https://www.gnu.org/licenses/>.
-
-package updates
-
-import (
-	"runtime"
-	"strings"
-)
-
-type VersionInfo struct {
-	Version          string
-	Revision         string
-	ReleaseDate      string   // Timestamp generated automatically
-	ReleaseNotes     string   // List of features, new line separated with leading dot e.g. `• example\n`
-	ReleaseFixedBugs string   // List of fixed bugs, same usage as release notes
-	FixedBugs        []string // Deprecated list of fixed bugs keeping for backward compatibility (mandatory for working versions up to 1.1.5)
-	URL              string   // Open browser and download (obsolete replaced by InstallerFile)
-
-	LandingPage   string // landing page for manual download
-	UpdateFile    string // automatic update file
-	InstallerFile string `json:",omitempty"` // manual update file
-	DebFile       string `json:",omitempty"` // debian package file
-	RpmFile       string `json:",omitempty"` // red hat package file
-	PkgFile       string `json:",omitempty"` // arch PKGBUILD file
-}
-
-func (info *VersionInfo) GetDownloadLink() string {
-	switch runtime.GOOS {
-	case "linux":
-		return strings.Join([]string{info.DebFile, info.RpmFile, info.PkgFile}, "\n")
-	default:
-		return info.InstallerFile
-	}
-}

internal/users/mocks/mocks.go

@@ -1,5 +1,5 @@
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/ProtonMail/proton-bridge/internal/users (interfaces: Configer,PanicHandler,ClientManager,CredentialsStorer,StoreMaker)
+// Source: github.com/ProtonMail/proton-bridge/internal/users (interfaces: Locator,PanicHandler,ClientManager,CredentialsStorer,StoreMaker)
 
 // Package mocks is a generated GoMock package.
 package mocks
@@ -13,69 +13,41 @@ import (
 	gomock "github.com/golang/mock/gomock"
 )
 
-// MockConfiger is a mock of Configer interface
-type MockConfiger struct {
+// MockLocator is a mock of Locator interface
+type MockLocator struct {
 	ctrl     *gomock.Controller
-	recorder *MockConfigerMockRecorder
+	recorder *MockLocatorMockRecorder
 }
 
-// MockConfigerMockRecorder is the mock recorder for MockConfiger
-type MockConfigerMockRecorder struct {
-	mock *MockConfiger
+// MockLocatorMockRecorder is the mock recorder for MockLocator
+type MockLocatorMockRecorder struct {
+	mock *MockLocator
 }
 
-// NewMockConfiger creates a new mock instance
-func NewMockConfiger(ctrl *gomock.Controller) *MockConfiger {
-	mock := &MockConfiger{ctrl: ctrl}
-	mock.recorder = &MockConfigerMockRecorder{mock}
+// NewMockLocator creates a new mock instance
+func NewMockLocator(ctrl *gomock.Controller) *MockLocator {
+	mock := &MockLocator{ctrl: ctrl}
+	mock.recorder = &MockLocatorMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use
-func (m *MockConfiger) EXPECT() *MockConfigerMockRecorder {
+func (m *MockLocator) EXPECT() *MockLocatorMockRecorder {
 	return m.recorder
 }
 
-// ClearData mocks base method
-func (m *MockConfiger) ClearData() error {
+// Clear mocks base method
+func (m *MockLocator) Clear() error {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClearData")
+	ret := m.ctrl.Call(m, "Clear")
 	ret0, _ := ret[0].(error)
 	return ret0
 }
 
-// ClearData indicates an expected call of ClearData
-func (mr *MockConfigerMockRecorder) ClearData() *gomock.Call {
+// Clear indicates an expected call of Clear
+func (mr *MockLocatorMockRecorder) Clear() *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClearData", reflect.TypeOf((*MockConfiger)(nil).ClearData))
-}
-
-// GetAPIConfig mocks base method
-func (m *MockConfiger) GetAPIConfig() *pmapi.ClientConfig {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetAPIConfig")
-	ret0, _ := ret[0].(*pmapi.ClientConfig)
-	return ret0
-}
-
-// GetAPIConfig indicates an expected call of GetAPIConfig
-func (mr *MockConfigerMockRecorder) GetAPIConfig() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAPIConfig", reflect.TypeOf((*MockConfiger)(nil).GetAPIConfig))
-}
-
-// GetVersion mocks base method
-func (m *MockConfiger) GetVersion() string {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetVersion")
-	ret0, _ := ret[0].(string)
-	return ret0
-}
-
-// GetVersion indicates an expected call of GetVersion
-func (mr *MockConfigerMockRecorder) GetVersion() *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersion", reflect.TypeOf((*MockConfiger)(nil).GetVersion))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockLocator)(nil).Clear))
 }
 
 // MockPanicHandler is a mock of PanicHandler interface

internal/users/types.go

@@ -24,11 +24,14 @@ import (
 )
 
 type Configer interface {
-	ClearData() error
-	GetVersion() string
+	GetAppVersion() string
 	GetAPIConfig() *pmapi.ClientConfig
 }
 
+type Locator interface {
+	Clear() error
+}
+
 type PanicHandler interface {
 	HandlePanic()
 }

internal/users/users.go

@@ -38,7 +38,7 @@ var (
 
 // Users is a struct handling users.
 type Users struct {
-	config        Configer
+	locations     Locator
 	panicHandler  PanicHandler
 	events        listener.Listener
 	clientManager ClientManager
@@ -64,7 +64,7 @@ type Users struct {
 }
 
 func New(
-	config Configer,
+	locations Locator,
 	panicHandler PanicHandler,
 	eventListener listener.Listener,
 	clientManager ClientManager,
@@ -75,7 +75,7 @@ func New(
 	log.Trace("Creating new users")
 
 	u := &Users{
-		config:                 config,
+		locations:              locations,
 		panicHandler:           panicHandler,
 		events:                 eventListener,
 		clientManager:          clientManager,
@@ -387,7 +387,8 @@ func (u *Users) GetUser(query string) (*User, error) {
 
 // ClearData closes all connections (to release db files and so on) and clears all data.
 func (u *Users) ClearData() error {
-	var result *multierror.Error
+	var result error
+
 	for _, user := range u.users {
 		if err := user.Logout(); err != nil {
 			result = multierror.Append(result, err)
@@ -396,10 +397,12 @@ func (u *Users) ClearData() error {
 			result = multierror.Append(result, err)
 		}
 	}
-	if err := u.config.ClearData(); err != nil {
+
+	if err := u.locations.Clear(); err != nil {
 		result = multierror.Append(result, err)
 	}
-	return result.ErrorOrNil()
+
+	return result
 }
 
 // DeleteUser deletes user completely; it logs user out from the API, stops any