"rsync for cloud storage" - Google Drive, S3, Dropbox, Backblaze B2, One Drive, Swift, Hubic, Wasabi, Google Cloud Storage, Azure Blob, Azure Files, Yandex Files
Go azure-blobazure-blob-storageazure-filesbackblaze-b2cloud-storagedropboxencryptionftpfuse-filesystemgogolanggoogle-cloud-storagegoogle-driveonedriveopenstack-swiftrclones3sftpsyncwebdav
smb: refresh Kerberos credentials when ccache file changes
Sudipto Baral9c7594d78f59
diff --git a/backend/smb/connpool.go b/backend/smb/connpool.goindex 9067b1f05..e040881d9 100644--- a/backend/smb/connpool.go+++ b/backend/smb/connpool.go@@ -38,7 +38,7 @@ func (f *Fs) dial(ctx context.Context, network, addr string) (*conn, error) {d := &smb2.Dialer{}if f.opt.UseKerberos {- cl, err := createKerberosClient(f.opt.KerberosCCache)+ cl, err := NewKerberosFactory().GetClient(f.opt.KerberosCCache)if err != nil {return nil, err}diff --git a/backend/smb/kerberos.go b/backend/smb/kerberos.goindex 58414cda1..fdbb19ddd 100644--- a/backend/smb/kerberos.go+++ b/backend/smb/kerberos.go@@ -7,17 +7,95 @@ import ("path/filepath""strings""sync"+ "time""github.com/jcmturner/gokrb5/v8/client""github.com/jcmturner/gokrb5/v8/config""github.com/jcmturner/gokrb5/v8/credentials")-var (- kerberosClient sync.Map // map[string]*client.Client- kerberosErr sync.Map // map[string]error-)+// KerberosFactory encapsulates dependencies and caches for Kerberos clients.+type KerberosFactory struct {+ // clientCache caches Kerberos clients keyed by resolved ccache path.+ // Clients are reused unless the associated ccache file changes.+ clientCache sync.Map // map[string]*client.Client++ // errCache caches errors encountered when loading Kerberos clients.+ // Prevents repeated attempts for paths that previously failed.+ errCache sync.Map // map[string]error++ // modTimeCache tracks the last known modification time of ccache files.+ // Used to detect changes and trigger credential refresh.+ modTimeCache sync.Map // map[string]time.Time++ loadCCache func(string) (*credentials.CCache, error)+ newClient func(*credentials.CCache, *config.Config, ...func(*client.Settings)) (*client.Client, error)+ loadConfig func() (*config.Config, error)+}++// NewKerberosFactory creates a new instance of KerberosFactory with default dependencies.+func NewKerberosFactory() *KerberosFactory {+ return &KerberosFactory{+ loadCCache: credentials.LoadCCache,+ newClient: client.NewFromCCache,+ loadConfig: defaultLoadKerberosConfig,+ }+}++// GetClient returns a cached Kerberos client or creates a new one if needed.+func (kf *KerberosFactory) GetClient(ccachePath string) (*client.Client, error) {+ resolvedPath, err := resolveCcachePath(ccachePath)+ if err != nil {+ return nil, err+ }++ stat, err := os.Stat(resolvedPath)+ if err != nil {+ kf.errCache.Store(resolvedPath, err)+ return nil, err+ }+ mtime := stat.ModTime()++ if oldMod, ok := kf.modTimeCache.Load(resolvedPath); ok {+ if oldTime, ok := oldMod.(time.Time); ok && oldTime.Equal(mtime) {+ if errVal, ok := kf.errCache.Load(resolvedPath); ok {+ return nil, errVal.(error)+ }+ if clientVal, ok := kf.clientCache.Load(resolvedPath); ok {+ return clientVal.(*client.Client), nil+ }+ }+ }+ // Load Kerberos config+ cfg, err := kf.loadConfig()+ if err != nil {+ kf.errCache.Store(resolvedPath, err)+ return nil, err+ }++ // Load ccache+ ccache, err := kf.loadCCache(resolvedPath)+ if err != nil {+ kf.errCache.Store(resolvedPath, err)+ return nil, err+ }++ // Create new client+ cl, err := kf.newClient(ccache, cfg)+ if err != nil {+ kf.errCache.Store(resolvedPath, err)+ return nil, err+ }++ // Cache and return+ kf.clientCache.Store(resolvedPath, cl)+ kf.errCache.Delete(resolvedPath)+ kf.modTimeCache.Store(resolvedPath, mtime)+ return cl, nil+}++// resolveCcachePath resolves the KRB5 ccache path.func resolveCcachePath(ccachePath string) (string, error) {if ccachePath == "" {ccachePath = os.Getenv("KRB5CCNAME")@@ -50,45 +128,11 @@ func resolveCcachePath(ccachePath string) (string, error) {}}-func loadKerberosConfig() (*config.Config, error) {+// defaultLoadKerberosConfig loads Kerberos config from default or env path.+func defaultLoadKerberosConfig() (*config.Config, error) {cfgPath := os.Getenv("KRB5_CONFIG")if cfgPath == "" {cfgPath = "/etc/krb5.conf"}return config.Load(cfgPath)}--// createKerberosClient creates a new Kerberos client.-func createKerberosClient(ccachePath string) (*client.Client, error) {- ccachePath, err := resolveCcachePath(ccachePath)- if err != nil {- return nil, err- }-- // check if we already have a client or an error for this ccache path- if errVal, ok := kerberosErr.Load(ccachePath); ok {- return nil, errVal.(error)- }- if clientVal, ok := kerberosClient.Load(ccachePath); ok {- return clientVal.(*client.Client), nil- }-- // create a new client if not found in the map- cfg, err := loadKerberosConfig()- if err != nil {- kerberosErr.Store(ccachePath, err)- return nil, err- }- ccache, err := credentials.LoadCCache(ccachePath)- if err != nil {- kerberosErr.Store(ccachePath, err)- return nil, err- }- cl, err := client.NewFromCCache(ccache, cfg)- if err != nil {- kerberosErr.Store(ccachePath, err)- return nil, err- }- kerberosClient.Store(ccachePath, cl)- return cl, nil-}diff --git a/backend/smb/kerberos_test.go b/backend/smb/kerberos_test.goindex 4bfe6d240..dc78b3bbf 100644--- a/backend/smb/kerberos_test.go+++ b/backend/smb/kerberos_test.go@@ -4,7 +4,11 @@ import ("os""path/filepath""testing"+ "time"+ "github.com/jcmturner/gokrb5/v8/client"+ "github.com/jcmturner/gokrb5/v8/config"+ "github.com/jcmturner/gokrb5/v8/credentials""github.com/stretchr/testify/assert")@@ -77,3 +81,62 @@ func TestResolveCcachePath(t *testing.T) {})}}++func TestKerberosFactory_GetClient_ReloadOnCcacheChange(t *testing.T) {+ // Create temp ccache file+ tmpFile, err := os.CreateTemp("", "krb5cc_test")+ assert.NoError(t, err)+ defer func() {+ if err := os.Remove(tmpFile.Name()); err != nil {+ t.Logf("Failed to remove temp file %s: %v", tmpFile.Name(), err)+ }+ }()++ unixPath := filepath.ToSlash(tmpFile.Name())+ ccachePath := "FILE:" + unixPath++ initialContent := []byte("CCACHE_VERSION 4\n")+ _, err = tmpFile.Write(initialContent)+ assert.NoError(t, err)+ assert.NoError(t, tmpFile.Close())++ // Setup mocks+ loadCallCount := 0+ mockLoadCCache := func(path string) (*credentials.CCache, error) {+ loadCallCount+++ return &credentials.CCache{}, nil+ }++ mockNewClient := func(cc *credentials.CCache, cfg *config.Config, opts ...func(*client.Settings)) (*client.Client, error) {+ return &client.Client{}, nil+ }++ mockLoadConfig := func() (*config.Config, error) {+ return &config.Config{}, nil+ }+ factory := &KerberosFactory{+ loadCCache: mockLoadCCache,+ newClient: mockNewClient,+ loadConfig: mockLoadConfig,+ }++ // First call — triggers loading+ _, err = factory.GetClient(ccachePath)+ assert.NoError(t, err)+ assert.Equal(t, 1, loadCallCount, "expected 1 load call")++ // Second call — should reuse cache, no additional load+ _, err = factory.GetClient(ccachePath)+ assert.NoError(t, err)+ assert.Equal(t, 1, loadCallCount, "expected cached reuse, no new load")++ // Simulate file update+ time.Sleep(1 * time.Second) // ensure mtime changes+ err = os.WriteFile(tmpFile.Name(), []byte("CCACHE_VERSION 4\n#updated"), 0600)+ assert.NoError(t, err)++ // Third call — should detect change, reload+ _, err = factory.GetClient(ccachePath)+ assert.NoError(t, err)+ assert.Equal(t, 2, loadCallCount, "expected reload on changed ccache")+}