From bb78eb8ab20f360b7dbc91701242d671c67cbf83 Mon Sep 17 00:00:00 2001 From: nielash Date: Mon, 2 Mar 2026 12:08:48 -0500 Subject: [PATCH] bisync: add missing rc params - fixes #7799 This adds 11 previously-missing rc params for newer bisync features. It also makes optional parameters truly optional. (Previously, callers were required to supply every single one, even if using the default value.) --- cmd/bisync/rc.go | 88 +++++++++++++++++++++++++++++++++++------------- 1 file changed, 65 insertions(+), 23 deletions(-) diff --git a/cmd/bisync/rc.go b/cmd/bisync/rc.go index c0d36a372..81bc402af 100644 --- a/cmd/bisync/rc.go +++ b/cmd/bisync/rc.go @@ -41,56 +41,86 @@ func rcBisync(ctx context.Context, in rc.Params) (out rc.Params, err error) { } if opt.Resync, err = in.GetBool("resync"); rc.NotErrParamNotFound(err) { - return + fs.Debugf("resync", "optional parameter is missing. using default value: %v", opt.Resync) } if opt.CheckAccess, err = in.GetBool("checkAccess"); rc.NotErrParamNotFound(err) { - return + fs.Debugf("checkAccess", "optional parameter is missing. using default value: %v", opt.CheckAccess) } if opt.Force, err = in.GetBool("force"); rc.NotErrParamNotFound(err) { - return + fs.Debugf("force", "optional parameter is missing. using default value: %v", opt.Force) } if opt.CreateEmptySrcDirs, err = in.GetBool("createEmptySrcDirs"); rc.NotErrParamNotFound(err) { - return + fs.Debugf("createEmptySrcDirs", "optional parameter is missing. using default value: %v", opt.CreateEmptySrcDirs) } if opt.RemoveEmptyDirs, err = in.GetBool("removeEmptyDirs"); rc.NotErrParamNotFound(err) { - return + fs.Debugf("removeEmptyDirs", "optional parameter is missing. using default value: %v", opt.RemoveEmptyDirs) } if opt.NoCleanup, err = in.GetBool("noCleanup"); rc.NotErrParamNotFound(err) { - return + fs.Debugf("noCleanup", "optional parameter is missing. using default value: %v", opt.NoCleanup) } if opt.IgnoreListingChecksum, err = in.GetBool("ignoreListingChecksum"); rc.NotErrParamNotFound(err) { - return + fs.Debugf("ignoreListingChecksum", "optional parameter is missing. using default value: %v", opt.IgnoreListingChecksum) } if opt.Resilient, err = in.GetBool("resilient"); rc.NotErrParamNotFound(err) { - return + fs.Debugf("resilient", "optional parameter is missing. using default value: %v", opt.Resilient) } - if opt.CheckFilename, err = in.GetString("checkFilename"); rc.NotErrParamNotFound(err) { - return + opt.CheckFilename = DefaultCheckFilename + fs.Debugf("checkFilename", "optional parameter is missing. using default value: %v", opt.CheckFilename) } if opt.FiltersFile, err = in.GetString("filtersFile"); rc.NotErrParamNotFound(err) { - return + fs.Debugf("filtersFile", "optional parameter is missing. using default value: %v", opt.FiltersFile) } if opt.Workdir, err = in.GetString("workdir"); rc.NotErrParamNotFound(err) { - return + // "" sets correct default later + fs.Debugf("workdir", "optional parameter is missing. using default value: %v", opt.Workdir) } - if opt.BackupDir1, err = in.GetString("backupdir1"); rc.NotErrParamNotFound(err) { - return + if opt.BackupDir1, err = in.GetString("backupDir1"); rc.NotErrParamNotFound(err) { + // we accept an alternate capitalization here for backward compatibility. + if opt.BackupDir1, err = in.GetString("backupdir1"); rc.NotErrParamNotFound(err) { + fs.Debugf("backupDir1", "optional parameter is missing. using default value: %v", opt.BackupDir1) + } } - if opt.BackupDir2, err = in.GetString("backupdir2"); rc.NotErrParamNotFound(err) { - return + if opt.BackupDir2, err = in.GetString("backupDir2"); rc.NotErrParamNotFound(err) { + // we accept an alternate capitalization here for backward compatibility. + if opt.BackupDir2, err = in.GetString("backupdir2"); rc.NotErrParamNotFound(err) { + fs.Debugf("backupDir2", "optional parameter is missing. using default value: %v", opt.BackupDir2) + } } - - checkSync, err := in.GetString("checkSync") - if rc.NotErrParamNotFound(err) { + if err = setEnum(in, "checkSync", "true", opt.CheckSync.Set); err != nil { return nil, err } - if checkSync == "" { - checkSync = "true" - } - if err := opt.CheckSync.Set(checkSync); err != nil { + if err = setEnum(in, "resyncMode", opt.ResyncMode.String(), opt.ResyncMode.Set); err != nil { return nil, err } + if err = setEnum(in, "conflictResolve", opt.ConflictResolve.String(), opt.ConflictResolve.Set); err != nil { + return nil, err + } + if err = setEnum(in, "conflictLoser", opt.ConflictLoser.String(), opt.ConflictLoser.Set); err != nil { + return nil, err + } + if opt.ConflictSuffixFlag, err = in.GetString("conflictSuffix"); rc.NotErrParamNotFound(err) { + fs.Debugf("conflictSuffix", "optional parameter is missing. using default value: %v", opt.ConflictSuffixFlag) + } + if opt.Recover, err = in.GetBool("recover"); rc.NotErrParamNotFound(err) { + fs.Debugf("recover", "optional parameter is missing. using default value: %v", opt.Recover) + } + if opt.CompareFlag, err = in.GetString("compare"); rc.NotErrParamNotFound(err) { + fs.Debugf("compare", "optional parameter is missing. using default value: %v", opt.CompareFlag) + } + if opt.Compare.NoSlowHash, err = in.GetBool("noSlowHash"); rc.NotErrParamNotFound(err) { + fs.Debugf("noSlowHash", "optional parameter is missing. using default value: %v", opt.Compare.NoSlowHash) + } + if opt.Compare.SlowHashSyncOnly, err = in.GetBool("slowHashSyncOnly"); rc.NotErrParamNotFound(err) { + fs.Debugf("slowHashSyncOnly", "optional parameter is missing. using default value: %v", opt.Compare.SlowHashSyncOnly) + } + if opt.Compare.DownloadHash, err = in.GetBool("downloadHash"); rc.NotErrParamNotFound(err) { + fs.Debugf("downloadHash", "optional parameter is missing. using default value: %v", opt.Compare.DownloadHash) + } + if opt.MaxLock, err = in.GetFsDuration("maxLock"); rc.NotErrParamNotFound(err) { + opt.MaxLock = 0 + fs.Debugf("maxLock", "optional parameter is missing. using default value: %v", opt.MaxLock) + } fs1, err := rc.GetFsNamed(octx, in, "path1") if err != nil { @@ -108,3 +138,15 @@ func rcBisync(ctx context.Context, in rc.Params) (out rc.Params, err error) { _, _ = log.Writer().Write(output) return rc.Params{"output": string(output)}, err } + +func setEnum(in rc.Params, name string, defaultVal string, set func(s string) error) error { + v, err := in.GetString(name) + if rc.NotErrParamNotFound(err) || v == "" { + v = defaultVal + fs.Debugf(name, "optional parameter is missing. using default value: %v", v) + } + if err := set(v); err != nil { + return err + } + return nil +}