common: route library logging through a caller-supplied Logger

Add a Logger interface (and matching Config.Logger field) whose method
set lines up with resty.Logger and go-proton-api's WithLogger option,
so callers can plug in a single adapter that captures all bridge log
output along with HTTP-layer warnings emitted by go-proton-api.

Convert the active stdlib log.Println / log.Printf call sites in
cache.go, drive.go, file_download.go, folder_recursive.go, mail.go and
common/user.go to use the configured logger via Config.GetLogger,
which falls back to the stdlib log package when no Logger is set so
existing callers see the same behaviour.

Downgrade the four log.Fatalln sites in cache.go and mail.go: a
library has no business calling os.Exit. The cache assertions become
logged errors (the offending branches were already unreachable in
practice), and the unsupported-recipient case in sendDraft now returns
a new ErrUnsupportedRecipientType.

Author: ncw

cache.go

@@ -2,10 +2,10 @@ package proton_api_bridge
 
 import (
 	"context"
-	"log"
 	"sync"
 
 	"github.com/ProtonMail/gopenpgp/v2/crypto"
+	"github.com/rclone/Proton-API-Bridge/common"
 	"github.com/rclone/go-proton-api"
 )
 
@@ -18,15 +18,17 @@ type cache struct {
 	data          map[string]*cacheEntry
 	children      map[string]map[string]interface{}
 	enableCaching bool
+	logger        common.Logger
 
 	sync.RWMutex
 }
 
-func newCache(enableCaching bool) *cache {
+func newCache(enableCaching bool, logger common.Logger) *cache {
 	return &cache{
 		data:          make(map[string]*cacheEntry),
 		children:      make(map[string]map[string]interface{}),
 		enableCaching: enableCaching,
+		logger:        logger,
 	}
 }
 
@@ -84,8 +86,10 @@ func (cache *cache) _insert(linkID string, link *proton.Link, kr *crypto.KeyRing
 
 		}
 	} else {
-		// TODO: we should never have missing link though
-		log.Fatalln("we should never have missing link though")
+		// Defensive guard: every caller of _insert passes a non-nil link,
+		// so this branch is unreachable in practice. Log a warning rather
+		// than crashing the process if the invariant is ever violated.
+		cache.logger.Errorf("cache._insert called with nil link for linkID %s", linkID)
 	}
 }
 
@@ -106,10 +110,10 @@ func (cache *cache) _remove_nolock(linkID string, includingChildren bool) {
 			delete(data, link.LinkID)
 			cache.children[link.ParentLinkID] = data
 		} else {
-			log.Fatalln("we have an issue for cache inconsistency where link is not found in the parent's map")
+			cache.logger.Errorf("cache inconsistency: link %s not found in parent %s's map", link.LinkID, link.ParentLinkID)
 		}
 	} else {
-		log.Fatalln("we have an issue for cache inconsistency where link's parent map is missing")
+		cache.logger.Errorf("cache inconsistency: parent map for %s is missing", link.ParentLinkID)
 	}
 
 	// we don't recursively go upward to clean up the parent's map

common/config.go

@@ -1,11 +1,30 @@
 package common
 
 import (
+	"log"
 	"net/http"
 	"os"
 	"runtime"
 )
 
+// Logger is the minimum interface the bridge needs to emit log lines.
+// Its method set matches resty.Logger and go-proton-api's WithLogger
+// option, so a single value can be forwarded straight through to the
+// underlying API client without conversion.
+type Logger interface {
+	Errorf(format string, v ...interface{})
+	Warnf(format string, v ...interface{})
+	Debugf(format string, v ...interface{})
+}
+
+// stdlibLogger preserves the bridge's historical "print to stdlib log"
+// behaviour for callers that don't supply a Logger via Config.
+type stdlibLogger struct{}
+
+func (stdlibLogger) Errorf(format string, v ...interface{}) { log.Printf("ERROR: "+format, v...) }
+func (stdlibLogger) Warnf(format string, v ...interface{})  { log.Printf("WARN: "+format, v...) }
+func (stdlibLogger) Debugf(format string, v ...interface{}) { log.Printf("DEBUG: "+format, v...) }
+
 type Config struct {
 	/* Constants */
 	AppVersion string
@@ -17,6 +36,14 @@ type Config struct {
 	// transport.
 	Transport http.RoundTripper
 
+	/* Logging */
+	// Logger, if non-nil, receives all log output produced by the bridge
+	// and is also forwarded to go-proton-api via proton.WithLogger so
+	// that HTTP-layer warnings/errors emitted by resty go through the
+	// same sink. When nil, the bridge falls back to printing through the
+	// stdlib log package.
+	Logger Logger
+
 	/* Login */
 	FirstLoginCredential *FirstLoginCredentialData
 	ReusableCredential   *ReusableCredentialData
@@ -35,6 +62,16 @@ type Config struct {
 	DataFolderName string
 }
 
+// GetLogger returns the configured Logger or a stdlib-backed default
+// when Config.Logger is nil. Callers should use this rather than reading
+// Config.Logger directly so they never need to nil-check.
+func (c *Config) GetLogger() Logger {
+	if c.Logger != nil {
+		return c.Logger
+	}
+	return stdlibLogger{}
+}
+
 type FirstLoginCredentialData struct {
 	Username        string
 	Password        string

common/proton_manager.go

@@ -13,6 +13,9 @@ func getProtonManager(config *Config) *proton.Manager {
 	if config.Transport != nil {
 		options = append(options, proton.WithTransport(config.Transport))
 	}
+	if config.Logger != nil {
+		options = append(options, proton.WithLogger(config.Logger))
+	}
 	m := proton.New(options...)
 
 	return m

common/user.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/base64"
 	"encoding/json"
-	"log"
 	"os"
 
 	"github.com/ProtonMail/gopenpgp/v2/crypto"
@@ -148,7 +147,7 @@ func Logout(ctx context.Context, config *Config, m *proton.Manager, c *proton.Cl
 	defer c.Close()
 
 	if config.CredentialCacheFile == "" {
-		log.Println("Logging out user")
+		config.GetLogger().Debugf("Logging out user")
 
 		// log out
 		err := c.AuthDelete(ctx)

drive.go

@@ -2,7 +2,6 @@ package proton_api_bridge
 
 import (
 	"context"
-	"log"
 
 	"github.com/rclone/Proton-API-Bridge/common"
 	"golang.org/x/sync/semaphore"
@@ -98,8 +97,9 @@ func NewProtonDrive(ctx context.Context, config *common.Config, authHandler prot
 		}
 
 		if !mainShareCheck {
-			log.Printf("mainShare %#v", mainShare)
-			log.Printf("shares %#v", shares)
+			logger := config.GetLogger()
+			logger.Errorf("mainShare %#v", mainShare)
+			logger.Errorf("shares %#v", shares)
 			return nil, nil, ErrMainSharePreconditionsFailed
 		}
 	}
@@ -146,7 +146,7 @@ func NewProtonDrive(ctx context.Context, config *common.Config, authHandler prot
 		addrData:         addrData,
 		signatureAddress: mainShare.Creator,
 
-		cache:                newCache(config.EnableCaching),
+		cache:                newCache(config.EnableCaching, config.GetLogger()),
 		blockUploadSemaphore: semaphore.NewWeighted(int64(config.ConcurrentBlockUploadCount)),
 		blockCryptoSemaphore: semaphore.NewWeighted(int64(config.ConcurrentFileCryptoCount)),
 	}, credentials, nil

file_download.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"io"
-	"log"
 
 	"github.com/ProtonMail/gopenpgp/v2/crypto"
 	"github.com/rclone/Proton-API-Bridge/utility"
@@ -171,7 +170,7 @@ func (protonDrive *ProtonDrive) DownloadFile(ctx context.Context, link *proton.L
 	}
 
 	if useFallbackDownload {
-		log.Println("Performing inefficient seek as metadata of encrypted file is missing")
+		protonDrive.Config.GetLogger().Warnf("Performing inefficient seek as metadata of encrypted file is missing")
 		n, err := io.CopyN(io.Discard, reader, offset)
 		if err != nil {
 			return nil, 0, nil, err

folder_recursive.go

@@ -3,7 +3,6 @@ package proton_api_bridge
 import (
 	"context"
 	"io"
-	"log"
 	"os"
 
 	"github.com/ProtonMail/gopenpgp/v2/crypto"
@@ -53,8 +52,9 @@ func (protonDrive *ProtonDrive) listDirectoriesRecursively(
 		}
 
 		if link.Type == proton.LinkTypeFile {
-			log.Println("Downloading", currentPath)
-			defer log.Println("Completes downloading", currentPath)
+			logger := protonDrive.Config.GetLogger()
+			logger.Debugf("Downloading %s", currentPath)
+			defer logger.Debugf("Completes downloading %s", currentPath)
 
 			reader, _, _, err := protonDrive.DownloadFile(ctx, link, 0)
 			if err != nil {

mail.go

@@ -3,7 +3,7 @@ package proton_api_bridge
 import (
 	"context"
 	"encoding/base64"
-	"log"
+	"errors"
 	"net/mail"
 	"os"
 	"path/filepath"
@@ -13,6 +13,11 @@ import (
 	"github.com/rclone/go-proton-api"
 )
 
+// ErrUnsupportedRecipientType is returned when the bridge is asked to
+// send mail to a recipient type it does not yet handle (currently
+// anything other than internal Proton accounts).
+var ErrUnsupportedRecipientType = errors.New("currently only support internal email sending")
+
 type MailSendingParameters struct {
 	TemplateFile          string
 	EmailSubject          string
@@ -22,8 +27,9 @@ type MailSendingParameters struct {
 }
 
 func (protonDrive *ProtonDrive) SendEmail(ctx context.Context, i int, errChan chan error, config *MailSendingParameters) {
-	log.Println("SendEmail in", i)
-	defer log.Println("SendEmail out", i)
+	logger := protonDrive.Config.GetLogger()
+	logger.Debugf("SendEmail in %d", i)
+	defer logger.Debugf("SendEmail out %d", i)
 
 	createDraftResp, err := protonDrive.createDraft(ctx, config)
 	if err != nil {
@@ -149,7 +155,7 @@ func (protonDrive *ProtonDrive) sendDraft(ctx context.Context, messageID string,
 		return err
 	}
 	if recipientType != proton.RecipientTypeInternal {
-		log.Fatalln("Currently only support internal email sending")
+		return ErrUnsupportedRecipientType
 	}
 	recipientKR, err := recipientPublicKeys.GetKeyRing()
 	if err != nil {