feat: add --remote flag to bd dolt push/pull commands (#3211)
Add PushRemote/PullRemote methods to RemoteStore interface, allowing push/pull to target a specific named remote instead of the default. Implementation: - Refactor Push/ForcePush/Pull to delegate to internal pushToRemote/ pullFromRemote methods with parameterized remote name - Parameterize credential routing (isGitProtocolRemote, shouldUseCLIForCredentials, shouldUseCLIForCloudAuth) to accept remote name instead of using s.remote - Make shouldUseCLIForCloudAuth per-scheme-aware: Azure env vars only trigger CLI routing for az:// remotes, not dolthub:// remotes - Add credentialsForRemote() helper that only returns creds when the target remote matches the default remote (prevents sending wrong creds to wrong host) - Add --remote flag to doltPushCmd and doltPullCmd in CLI - Implement PushRemote/PullRemote on EmbeddedDoltStore Backwards compatibility: - Push(ctx)/Pull(ctx)/ForcePush(ctx) signatures unchanged - No --remote flag = exact same behavior as today - PushTo/PullFrom for federation peers unchanged Closes: bd-4v3 Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
parent
be8edaac3d
commit
73d72ec0fa
7 changed files with 363 additions and 133 deletions
|
|
@ -215,7 +215,10 @@ For Hosted Dolt, set DOLT_REMOTE_USER and DOLT_REMOTE_PASSWORD environment
|
|||
variables for authentication.
|
||||
|
||||
Use --force to overwrite remote changes (e.g., when the remote has
|
||||
uncommitted changes in its working set).`,
|
||||
uncommitted changes in its working set).
|
||||
|
||||
Use --remote to push to a specific named remote instead of the default.
|
||||
The remote must already exist (see 'bd dolt remote add').`,
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
ctx := context.Background()
|
||||
st := getStore()
|
||||
|
|
@ -224,6 +227,23 @@ uncommitted changes in its working set).`,
|
|||
os.Exit(1)
|
||||
}
|
||||
force, _ := cmd.Flags().GetBool("force")
|
||||
remote, _ := cmd.Flags().GetString("remote")
|
||||
if remote != "" {
|
||||
fmt.Printf("Pushing to Dolt remote %q...\n", remote)
|
||||
if err := st.PushRemote(ctx, remote, force); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
|
||||
if isRemoteNotFoundErr(err) {
|
||||
fmt.Fprintf(os.Stderr, "\nRemote %q is not configured.\n", remote)
|
||||
fmt.Fprintln(os.Stderr, "Use 'bd dolt remote add <name> <url>' to add it.")
|
||||
fmt.Fprintln(os.Stderr, "Use 'bd dolt remote list' to see configured remotes.")
|
||||
} else if isDivergedHistoryErr(err) {
|
||||
printDivergedHistoryGuidance("push --force")
|
||||
}
|
||||
os.Exit(1)
|
||||
}
|
||||
fmt.Println("Push complete.")
|
||||
return
|
||||
}
|
||||
fmt.Println("Pushing to Dolt remote...")
|
||||
|
||||
var pushErr error
|
||||
|
|
@ -258,7 +278,10 @@ var doltPullCmd = &cobra.Command{
|
|||
|
||||
Requires a Dolt remote to be configured in the database directory.
|
||||
For Hosted Dolt, set DOLT_REMOTE_USER and DOLT_REMOTE_PASSWORD environment
|
||||
variables for authentication.`,
|
||||
variables for authentication.
|
||||
|
||||
Use --remote to pull from a specific named remote instead of the default.
|
||||
The remote must already exist (see 'bd dolt remote add').`,
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
ctx := context.Background()
|
||||
st := getStore()
|
||||
|
|
@ -266,6 +289,23 @@ variables for authentication.`,
|
|||
fmt.Fprintf(os.Stderr, "Error: no store available\n")
|
||||
os.Exit(1)
|
||||
}
|
||||
remote, _ := cmd.Flags().GetString("remote")
|
||||
if remote != "" {
|
||||
fmt.Printf("Pulling from Dolt remote %q...\n", remote)
|
||||
if err := st.PullRemote(ctx, remote); err != nil {
|
||||
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
|
||||
if isRemoteNotFoundErr(err) {
|
||||
fmt.Fprintf(os.Stderr, "\nRemote %q is not configured.\n", remote)
|
||||
fmt.Fprintln(os.Stderr, "Use 'bd dolt remote add <name> <url>' to add it.")
|
||||
fmt.Fprintln(os.Stderr, "Use 'bd dolt remote list' to see configured remotes.")
|
||||
} else if isDivergedHistoryErr(err) {
|
||||
printDivergedHistoryGuidance("pull")
|
||||
}
|
||||
os.Exit(1)
|
||||
}
|
||||
fmt.Println("Pull complete.")
|
||||
return
|
||||
}
|
||||
fmt.Println("Pulling from Dolt remote...")
|
||||
if err := st.Pull(ctx); err != nil {
|
||||
if isRemoteNotFoundErr(err) {
|
||||
|
|
@ -1104,6 +1144,8 @@ func init() {
|
|||
doltSetCmd.Flags().Bool("update-config", false, "Also write to config.yaml for team-wide defaults")
|
||||
doltStopCmd.Flags().Bool("force", false, "Force stop the server")
|
||||
doltPushCmd.Flags().Bool("force", false, "Force push (overwrite remote changes)")
|
||||
doltPushCmd.Flags().String("remote", "", "Push to a specific named remote instead of the default")
|
||||
doltPullCmd.Flags().String("remote", "", "Pull from a specific named remote instead of the default")
|
||||
doltCommitCmd.Flags().StringP("message", "m", "", "Commit message (default: auto-generated)")
|
||||
doltCleanDatabasesCmd.Flags().Bool("dry-run", false, "Show what would be dropped without dropping")
|
||||
doltRemoteRemoveCmd.Flags().Bool("force", false, "Force remove even when SQL and CLI URLs conflict")
|
||||
|
|
|
|||
|
|
@ -521,8 +521,8 @@ func (s *DoltStore) shouldUseCLIForPeerCredentials(_ context.Context, peer strin
|
|||
// 2. Server is in server mode (not embedded)
|
||||
// 3. Local CLI directory is available
|
||||
// 4. The remote is configured in the local CLI directory
|
||||
func (s *DoltStore) shouldUseCLIForCredentials(_ context.Context) bool {
|
||||
if s.remoteUser == "" && s.remotePassword == "" {
|
||||
func (s *DoltStore) shouldUseCLIForCredentials(_ context.Context, remote string, creds *remoteCredentials) bool {
|
||||
if creds.empty() {
|
||||
return false // no credentials to pass
|
||||
}
|
||||
if !s.serverMode {
|
||||
|
|
@ -535,27 +535,50 @@ func (s *DoltStore) shouldUseCLIForCredentials(_ context.Context) bool {
|
|||
// Only route to CLI if the remote is configured locally.
|
||||
// Shared server / external server modes may have CLIDir pointing
|
||||
// to wrong directory — FindCLIRemote returns "" in those cases.
|
||||
return doltutil.FindCLIRemote(cliDir, s.remote) != ""
|
||||
return doltutil.FindCLIRemote(cliDir, remote) != ""
|
||||
}
|
||||
|
||||
// cloudAuthEnvPrefixes lists environment variable prefixes used by cloud
|
||||
// storage providers for authentication. When any of these are set and the
|
||||
// store is in server mode, push/pull must route through a CLI subprocess
|
||||
// so the dolt process inherits the current env vars. The SQL path
|
||||
// (CALL DOLT_PUSH/PULL) executes inside the dolt-sql-server, which only
|
||||
// has env vars from when it was started — not from the current shell.
|
||||
var cloudAuthEnvPrefixes = []string{
|
||||
"AZURE_STORAGE_", // Azure Blob Storage (AZURE_STORAGE_ACCOUNT, AZURE_STORAGE_KEY, AZURE_STORAGE_SAS_TOKEN)
|
||||
"AWS_", // AWS S3 (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN, AWS_REGION)
|
||||
"GOOGLE_", // GCS (GOOGLE_APPLICATION_CREDENTIALS)
|
||||
"GCS_", // GCS alternate (GCS_CREDENTIALS_FILE)
|
||||
"OCI_", // Oracle Cloud Infrastructure
|
||||
"DOLT_REMOTE_", // Dolt-specific remote credentials
|
||||
// cloudAuthSchemeMap maps remote URL scheme prefixes to the environment
|
||||
// variable prefixes that provide credentials for that scheme. Only env vars
|
||||
// relevant to the remote's scheme are checked, preventing misrouting when
|
||||
// multiple remotes use different cloud providers (e.g., DoltHub + Azure).
|
||||
//
|
||||
// The CLI subprocess inherits the current process env, so these env vars
|
||||
// reach the dolt binary. The SQL server process may not have them if it was
|
||||
// started in a different context (GH#6).
|
||||
var cloudAuthSchemeMap = map[string][]string{
|
||||
"az://": {"AZURE_STORAGE_"}, // Azure Blob Storage
|
||||
"s3://": {"AWS_"}, // AWS S3
|
||||
"gs://": {"GOOGLE_", "GCS_"}, // Google Cloud Storage
|
||||
"oci://": {"OCI_"}, // Oracle Cloud Infrastructure
|
||||
"dolthub://": {"DOLT_REMOTE_"}, // DoltHub
|
||||
"https://": {"DOLT_REMOTE_"}, // Hosted Dolt / DoltHub HTTPS
|
||||
"http://": {"DOLT_REMOTE_"}, // Hosted Dolt HTTP
|
||||
}
|
||||
|
||||
// envPrefixesForRemoteURL returns the env var prefixes relevant to the
|
||||
// given remote URL based on its scheme. Returns nil for unrecognized schemes
|
||||
// (git-protocol remotes are handled by isGitProtocolRemote, not here).
|
||||
func envPrefixesForRemoteURL(url string) []string {
|
||||
for scheme, prefixes := range cloudAuthSchemeMap {
|
||||
if strings.HasPrefix(url, scheme) {
|
||||
return prefixes
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// shouldUseCLIForCloudAuth returns true when CLI subprocess routing should
|
||||
// be used for push/pull because cloud storage credentials are present in the
|
||||
// environment and the store is using an external dolt-sql-server.
|
||||
// be used for push/pull because cloud storage credentials relevant to this
|
||||
// specific remote are present in the environment and the store is using an
|
||||
// external dolt-sql-server.
|
||||
//
|
||||
// Unlike a global heuristic, this checks only the env var prefixes that
|
||||
// match the remote's URL scheme. An Azure env var (AZURE_STORAGE_ACCOUNT)
|
||||
// will trigger CLI routing for an az:// remote but NOT for a dolthub:// remote.
|
||||
//
|
||||
// The CLI remote URL is used for scheme detection because that is the URL
|
||||
// the CLI subprocess will actually use (SQL remotes may differ due to drift).
|
||||
//
|
||||
// When bd connects to an external dolt-sql-server (server mode), CALL
|
||||
// DOLT_PUSH/PULL executes inside the server process. That process only has
|
||||
|
|
@ -563,7 +586,7 @@ var cloudAuthEnvPrefixes = []string{
|
|||
// changed) after the server started, the SQL path silently fails to
|
||||
// authenticate. Routing through a CLI subprocess (dolt push/pull) ensures
|
||||
// the child process inherits the current environment (GH#6).
|
||||
func (s *DoltStore) shouldUseCLIForCloudAuth() bool {
|
||||
func (s *DoltStore) shouldUseCLIForCloudAuth(remote string) bool {
|
||||
if !s.serverMode {
|
||||
return false // embedded mode: env vars are in-process
|
||||
}
|
||||
|
|
@ -571,11 +594,16 @@ func (s *DoltStore) shouldUseCLIForCloudAuth() bool {
|
|||
if cliDir == "" {
|
||||
return false
|
||||
}
|
||||
if doltutil.FindCLIRemote(cliDir, s.remote) == "" {
|
||||
cliURL := doltutil.FindCLIRemote(cliDir, remote)
|
||||
if cliURL == "" {
|
||||
return false
|
||||
}
|
||||
prefixes := envPrefixesForRemoteURL(cliURL)
|
||||
if len(prefixes) == 0 {
|
||||
return false // unknown scheme — not a cloud remote
|
||||
}
|
||||
for _, e := range os.Environ() {
|
||||
for _, prefix := range cloudAuthEnvPrefixes {
|
||||
for _, prefix := range prefixes {
|
||||
if strings.HasPrefix(e, prefix) {
|
||||
return true
|
||||
}
|
||||
|
|
|
|||
|
|
@ -301,6 +301,10 @@ func TestCredentialKeyCreatesBeadsDir(t *testing.T) {
|
|||
// setupCredentialTestStore creates a DoltStore with a dolt-initialized CLI directory
|
||||
// and "origin" remote for credential routing tests. Requires dolt CLI.
|
||||
func setupCredentialTestStore(t *testing.T, remoteUser, remotePassword string, serverMode, setupRemote bool) *DoltStore {
|
||||
return setupCredentialTestStoreWithURL(t, remoteUser, remotePassword, serverMode, setupRemote, "origin", "https://example.com/repo")
|
||||
}
|
||||
|
||||
func setupCredentialTestStoreWithURL(t *testing.T, remoteUser, remotePassword string, serverMode, setupRemote bool, remoteName, remoteURL string) *DoltStore {
|
||||
t.Helper()
|
||||
tmpDir := t.TempDir()
|
||||
dbName := "testdb"
|
||||
|
|
@ -315,7 +319,7 @@ func setupCredentialTestStore(t *testing.T, remoteUser, remotePassword string, s
|
|||
if out, err := cmd.CombinedOutput(); err != nil {
|
||||
t.Fatalf("dolt init failed: %s: %v", out, err)
|
||||
}
|
||||
cmd = exec.Command("dolt", "remote", "add", "origin", "https://example.com/repo")
|
||||
cmd = exec.Command("dolt", "remote", "add", remoteName, remoteURL)
|
||||
cmd.Dir = dbDir
|
||||
if out, err := cmd.CombinedOutput(); err != nil {
|
||||
t.Fatalf("dolt remote add failed: %s: %v", out, err)
|
||||
|
|
@ -328,7 +332,7 @@ func setupCredentialTestStore(t *testing.T, remoteUser, remotePassword string, s
|
|||
serverMode: serverMode,
|
||||
dbPath: tmpDir,
|
||||
database: dbName,
|
||||
remote: "origin",
|
||||
remote: remoteName,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -359,7 +363,8 @@ func TestCredentialCLIRouting(t *testing.T) {
|
|||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
store := setupCredentialTestStore(t, tt.remoteUser, tt.remotePassword, tt.serverMode, tt.setupRemote)
|
||||
got := store.shouldUseCLIForCredentials(context.Background())
|
||||
creds := store.mainRemoteCredentials()
|
||||
got := store.shouldUseCLIForCredentials(context.Background(), store.remote, creds)
|
||||
if got != tt.wantCLI {
|
||||
t.Errorf("shouldUseCLIForCredentials() = %v, want %v", got, tt.wantCLI)
|
||||
}
|
||||
|
|
@ -378,7 +383,7 @@ func TestCredentialCLIRoutingExternalServer(t *testing.T) {
|
|||
database: "testdb",
|
||||
remote: "origin",
|
||||
}
|
||||
if store.shouldUseCLIForCredentials(context.Background()) {
|
||||
if store.shouldUseCLIForCredentials(context.Background(), store.remote, store.mainRemoteCredentials()) {
|
||||
t.Error("expected false for external server mode (no CLI remote in CLIDir)")
|
||||
}
|
||||
}
|
||||
|
|
@ -395,7 +400,7 @@ func TestCredentialCLIRoutingNoRemote(t *testing.T) {
|
|||
database: "nodb",
|
||||
remote: "origin",
|
||||
}
|
||||
if store.shouldUseCLIForCredentials(context.Background()) {
|
||||
if store.shouldUseCLIForCredentials(context.Background(), store.remote, store.mainRemoteCredentials()) {
|
||||
t.Error("expected false when CLI remote does not exist")
|
||||
}
|
||||
}
|
||||
|
|
@ -528,38 +533,160 @@ func TestCloudAuthCLIRouting(t *testing.T) {
|
|||
}
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
serverMode bool
|
||||
setupRemote bool
|
||||
envKey string // env var to set (empty = none)
|
||||
envValue string
|
||||
wantCLI bool
|
||||
name string
|
||||
remoteURL string // URL scheme determines which env vars are relevant
|
||||
envKey string // env var to set (empty = none)
|
||||
envValue string
|
||||
wantCLI bool
|
||||
}{
|
||||
// Positive: cloud env + server mode + remote configured → CLI
|
||||
{"azure storage account", true, true, "AZURE_STORAGE_ACCOUNT", "myaccount", true},
|
||||
{"azure storage key", true, true, "AZURE_STORAGE_KEY", "mykey", true},
|
||||
{"aws access key", true, true, "AWS_ACCESS_KEY_ID", "AKID", true},
|
||||
{"aws secret key", true, true, "AWS_SECRET_ACCESS_KEY", "secret", true},
|
||||
{"google creds", true, true, "GOOGLE_APPLICATION_CREDENTIALS", "/path/to/creds.json", true},
|
||||
{"gcs creds file", true, true, "GCS_CREDENTIALS_FILE", "/path/to/creds.json", true},
|
||||
{"oci var", true, true, "OCI_TENANCY", "ocid1.tenancy", true},
|
||||
{"dolt remote user", true, true, "DOLT_REMOTE_USER", "admin", true},
|
||||
// Negative: missing conditions → SQL fallback
|
||||
{"no cloud env", true, true, "", "", false},
|
||||
{"embedded mode", false, true, "AZURE_STORAGE_ACCOUNT", "myaccount", false},
|
||||
{"no CLI remote", true, false, "AZURE_STORAGE_ACCOUNT", "myaccount", false},
|
||||
// Per-scheme positive: env var matches remote's scheme → CLI routing
|
||||
{"azure env + az:// remote", "az://account.blob.core.windows.net/container", "AZURE_STORAGE_ACCOUNT", "myaccount", true},
|
||||
{"azure key + az:// remote", "az://account.blob.core.windows.net/container", "AZURE_STORAGE_KEY", "mykey", true},
|
||||
{"aws env + s3:// remote", "s3://my-bucket/path", "AWS_ACCESS_KEY_ID", "AKID", true},
|
||||
{"aws secret + s3:// remote", "s3://my-bucket/path", "AWS_SECRET_ACCESS_KEY", "secret", true},
|
||||
{"google creds + gs:// remote", "gs://my-bucket/path", "GOOGLE_APPLICATION_CREDENTIALS", "/path/to/creds.json", true},
|
||||
{"gcs creds + gs:// remote", "gs://my-bucket/path", "GCS_CREDENTIALS_FILE", "/path/to/creds.json", true},
|
||||
{"oci env + oci:// remote", "oci://my-namespace/my-bucket/path", "OCI_TENANCY", "ocid1.tenancy", true},
|
||||
{"dolt env + dolthub:// remote", "dolthub://org/beads", "DOLT_REMOTE_USER", "admin", true},
|
||||
{"dolt env + https:// remote", "https://example.com/repo", "DOLT_REMOTE_USER", "admin", true},
|
||||
{"dolt env + http:// remote", "http://example.com/repo", "DOLT_REMOTE_USER", "admin", true},
|
||||
|
||||
// Per-scheme negative: env var does NOT match remote's scheme → SQL fallback
|
||||
{"azure env + dolthub:// remote", "dolthub://org/beads", "AZURE_STORAGE_ACCOUNT", "myaccount", false},
|
||||
{"azure env + https:// remote", "https://example.com/repo", "AZURE_STORAGE_ACCOUNT", "myaccount", false},
|
||||
{"azure env + s3:// remote", "s3://my-bucket/path", "AZURE_STORAGE_ACCOUNT", "myaccount", false},
|
||||
{"aws env + az:// remote", "az://account.blob.core.windows.net/container", "AWS_ACCESS_KEY_ID", "AKID", false},
|
||||
{"dolt env + az:// remote", "az://account.blob.core.windows.net/container", "DOLT_REMOTE_USER", "admin", false},
|
||||
|
||||
// Structural negative: missing conditions → SQL fallback
|
||||
{"no cloud env", "az://account.blob.core.windows.net/container", "", "", false},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
// Use a clean store (no remoteUser/remotePassword — cloud auth uses env vars)
|
||||
store := setupCredentialTestStore(t, "", "", tt.serverMode, tt.setupRemote)
|
||||
store := setupCredentialTestStoreWithURL(t, "", "", true, true, "origin", tt.remoteURL)
|
||||
if tt.envKey != "" {
|
||||
t.Setenv(tt.envKey, tt.envValue)
|
||||
}
|
||||
got := store.shouldUseCLIForCloudAuth()
|
||||
got := store.shouldUseCLIForCloudAuth(store.remote)
|
||||
if got != tt.wantCLI {
|
||||
t.Errorf("shouldUseCLIForCloudAuth() = %v, want %v", got, tt.wantCLI)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCloudAuthCLIRoutingStructural(t *testing.T) {
|
||||
if _, err := exec.LookPath("dolt"); err != nil {
|
||||
t.Skip("dolt not installed")
|
||||
}
|
||||
|
||||
t.Run("embedded mode", func(t *testing.T) {
|
||||
store := setupCredentialTestStoreWithURL(t, "", "", false, true, "origin", "az://account.blob.core.windows.net/container")
|
||||
t.Setenv("AZURE_STORAGE_ACCOUNT", "myaccount")
|
||||
if store.shouldUseCLIForCloudAuth(store.remote) {
|
||||
t.Error("expected false in embedded mode")
|
||||
}
|
||||
})
|
||||
t.Run("no CLI remote", func(t *testing.T) {
|
||||
store := setupCredentialTestStoreWithURL(t, "", "", true, false, "origin", "az://account.blob.core.windows.net/container")
|
||||
t.Setenv("AZURE_STORAGE_ACCOUNT", "myaccount")
|
||||
if store.shouldUseCLIForCloudAuth(store.remote) {
|
||||
t.Error("expected false when CLI remote not configured")
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// TestPerRemoteCloudAuthHybrid verifies the core use case: a hybrid setup with
|
||||
// DoltHub (primary) + Azure (backup) remotes. AZURE_STORAGE_ACCOUNT should
|
||||
// trigger CLI routing ONLY for the Azure remote, not the DoltHub remote.
|
||||
func TestPerRemoteCloudAuthHybrid(t *testing.T) {
|
||||
if _, err := exec.LookPath("dolt"); err != nil {
|
||||
t.Skip("dolt not installed")
|
||||
}
|
||||
|
||||
tmpDir := t.TempDir()
|
||||
dbName := "testdb"
|
||||
dbDir := filepath.Join(tmpDir, dbName)
|
||||
if err := os.MkdirAll(dbDir, 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
cmd := exec.Command("dolt", "init")
|
||||
cmd.Dir = dbDir
|
||||
if out, err := cmd.CombinedOutput(); err != nil {
|
||||
t.Fatalf("dolt init: %s: %v", out, err)
|
||||
}
|
||||
// Add two remotes: DoltHub primary + Azure backup
|
||||
cmd = exec.Command("dolt", "remote", "add", "primary", "dolthub://org/beads")
|
||||
cmd.Dir = dbDir
|
||||
if out, err := cmd.CombinedOutput(); err != nil {
|
||||
t.Fatalf("dolt remote add primary: %s: %v", out, err)
|
||||
}
|
||||
cmd = exec.Command("dolt", "remote", "add", "backup", "az://account.blob.core.windows.net/dolt/beads")
|
||||
cmd.Dir = dbDir
|
||||
if out, err := cmd.CombinedOutput(); err != nil {
|
||||
t.Fatalf("dolt remote add backup: %s: %v", out, err)
|
||||
}
|
||||
|
||||
store := &DoltStore{
|
||||
serverMode: true,
|
||||
dbPath: tmpDir,
|
||||
database: dbName,
|
||||
remote: "primary",
|
||||
}
|
||||
|
||||
t.Setenv("AZURE_STORAGE_ACCOUNT", "myaccount")
|
||||
|
||||
// Azure remote should get CLI routing (AZURE_STORAGE_ env matches az:// scheme)
|
||||
if !store.shouldUseCLIForCloudAuth("backup") {
|
||||
t.Error("expected CLI routing for az:// remote when AZURE_STORAGE_ACCOUNT is set")
|
||||
}
|
||||
|
||||
// DoltHub remote should NOT get CLI routing (AZURE_STORAGE_ does not match dolthub:// scheme)
|
||||
if store.shouldUseCLIForCloudAuth("primary") {
|
||||
t.Error("expected SQL routing for dolthub:// remote when AZURE_STORAGE_ACCOUNT is set — per-remote resolution should prevent misrouting")
|
||||
}
|
||||
}
|
||||
|
||||
// TestEnvPrefixesForRemoteURL verifies the scheme-to-env-prefix mapping.
|
||||
func TestEnvPrefixesForRemoteURL(t *testing.T) {
|
||||
tests := []struct {
|
||||
url string
|
||||
wantNil bool
|
||||
wantHas string // one prefix we expect to find
|
||||
}{
|
||||
{"az://account.blob.core.windows.net/container", false, "AZURE_STORAGE_"},
|
||||
{"s3://my-bucket/path", false, "AWS_"},
|
||||
{"gs://my-bucket/path", false, "GOOGLE_"},
|
||||
{"oci://namespace/bucket/path", false, "OCI_"},
|
||||
{"dolthub://org/repo", false, "DOLT_REMOTE_"},
|
||||
{"https://dolthub.com/org/repo", false, "DOLT_REMOTE_"},
|
||||
{"http://localhost:8080/repo", false, "DOLT_REMOTE_"},
|
||||
{"git+ssh://host/repo", true, ""}, // git protocol — handled elsewhere
|
||||
{"ssh://host/repo", true, ""}, // git protocol — handled elsewhere
|
||||
{"file:///path/to/repo", true, ""}, // local filesystem — no cloud auth
|
||||
{"git@host:repo.git", true, ""}, // SCP-style — handled elsewhere
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.url, func(t *testing.T) {
|
||||
got := envPrefixesForRemoteURL(tt.url)
|
||||
if tt.wantNil && got != nil {
|
||||
t.Errorf("envPrefixesForRemoteURL(%q) = %v, want nil", tt.url, got)
|
||||
}
|
||||
if !tt.wantNil {
|
||||
if got == nil {
|
||||
t.Fatalf("envPrefixesForRemoteURL(%q) = nil, want non-nil", tt.url)
|
||||
}
|
||||
found := false
|
||||
for _, p := range got {
|
||||
if p == tt.wantHas {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
t.Errorf("envPrefixesForRemoteURL(%q) = %v, missing %q", tt.url, got, tt.wantHas)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1092,7 +1092,7 @@ func TestGitRemoteExternalServerRouting(t *testing.T) {
|
|||
|
||||
// SQL sees git+https:// remote in testdb; CLI directory (clientDataDir) has none.
|
||||
// isGitProtocolRemote should return false to route through SQL.
|
||||
require.False(t, store.isGitProtocolRemote(ctx))
|
||||
require.False(t, store.isGitProtocolRemote(ctx, store.remote))
|
||||
}
|
||||
|
||||
// TestCredentialCLIRoutingE2E verifies that Push succeeds via CLI subprocess
|
||||
|
|
@ -1218,8 +1218,8 @@ func TestCredentialCLIRoutingE2E(t *testing.T) {
|
|||
t.Cleanup(func() { store.Close() })
|
||||
|
||||
// Verify preconditions: not a git-protocol remote, but credentials trigger CLI routing
|
||||
require.False(t, store.isGitProtocolRemote(ctx), "file:// is not git-protocol")
|
||||
require.True(t, store.shouldUseCLIForCredentials(ctx), "should route through CLI for credentials")
|
||||
require.False(t, store.isGitProtocolRemote(ctx, store.remote), "file:// is not git-protocol")
|
||||
require.True(t, store.shouldUseCLIForCredentials(ctx, store.remote, store.mainRemoteCredentials()), "should route through CLI for credentials")
|
||||
require.True(t, store.serverMode, "store should be in server mode")
|
||||
|
||||
// 7. Push should succeed via CLI credential routing
|
||||
|
|
|
|||
|
|
@ -1806,25 +1806,25 @@ func (s *DoltStore) buildBatchCommitMessage(ctx context.Context, actor string) s
|
|||
// server may lack the git credentials, SSH keys, or credential helpers needed for
|
||||
// network I/O to external git hosts. Returns false when the remote exists only on
|
||||
// an externally-managed server's filesystem and not in the local dbPath.
|
||||
func (s *DoltStore) isGitProtocolRemote(ctx context.Context) bool {
|
||||
func (s *DoltStore) isGitProtocolRemote(ctx context.Context, remote string) bool {
|
||||
// Check SQL remotes first
|
||||
remotes, err := s.ListRemotes(ctx)
|
||||
if err == nil {
|
||||
for _, r := range remotes {
|
||||
if r.Name == s.remote {
|
||||
if r.Name == remote {
|
||||
if !doltutil.IsGitProtocolURL(r.URL) {
|
||||
return false
|
||||
}
|
||||
// Verify remote exists in CLI directory before routing to CLI push/pull.
|
||||
// When the dolt sql-server is externally managed, remotes may exist only
|
||||
// on the server's filesystem, not in the local dbPath.
|
||||
return s.CLIDir() != "" && doltutil.FindCLIRemote(s.CLIDir(), s.remote) != ""
|
||||
return s.CLIDir() != "" && doltutil.FindCLIRemote(s.CLIDir(), remote) != ""
|
||||
}
|
||||
}
|
||||
}
|
||||
// Fall back to CLI remotes (covers drift where remote exists only in filesystem)
|
||||
if s.CLIDir() != "" {
|
||||
if url := doltutil.FindCLIRemote(s.CLIDir(), s.remote); url != "" {
|
||||
if url := doltutil.FindCLIRemote(s.CLIDir(), remote); url != "" {
|
||||
return doltutil.IsGitProtocolURL(url)
|
||||
}
|
||||
}
|
||||
|
|
@ -1839,18 +1839,28 @@ func (s *DoltStore) mainRemoteCredentials() *remoteCredentials {
|
|||
return &remoteCredentials{username: s.remoteUser, password: s.remotePassword}
|
||||
}
|
||||
|
||||
// credentialsForRemote returns credentials only when the target remote is the
|
||||
// default remote (s.remote). Non-default remotes get nil creds to avoid sending
|
||||
// the wrong credentials to the wrong host.
|
||||
func (s *DoltStore) credentialsForRemote(remote string) *remoteCredentials {
|
||||
if remote == s.remote {
|
||||
return s.mainRemoteCredentials()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// doltCLIPush shells out to `dolt push` from the database directory.
|
||||
// Used for git-protocol remotes where CALL DOLT_PUSH times out through the SQL connection.
|
||||
// If creds is non-nil, credentials are set on the subprocess environment only,
|
||||
// avoiding process-wide env var races with concurrent goroutines.
|
||||
func (s *DoltStore) doltCLIPush(ctx context.Context, force bool, creds *remoteCredentials) error {
|
||||
func (s *DoltStore) doltCLIPush(ctx context.Context, remote string, force bool, creds *remoteCredentials) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, cliExecTimeout)
|
||||
defer cancel()
|
||||
args := []string{"push"}
|
||||
if force {
|
||||
args = append(args, "--force")
|
||||
}
|
||||
args = append(args, s.remote, s.branch)
|
||||
args = append(args, remote, s.branch)
|
||||
cmd := exec.CommandContext(ctx, "dolt", args...) // #nosec G204 -- fixed command with validated remote/branch
|
||||
cmd.Dir = s.CLIDir()
|
||||
creds.applyToCmd(cmd)
|
||||
|
|
@ -1864,10 +1874,10 @@ func (s *DoltStore) doltCLIPush(ctx context.Context, force bool, creds *remoteCr
|
|||
// doltCLIPull shells out to `dolt pull` from the database directory.
|
||||
// Used for git-protocol remotes where CALL DOLT_PULL times out through the SQL connection.
|
||||
// If creds is non-nil, credentials are set on the subprocess environment only.
|
||||
func (s *DoltStore) doltCLIPull(ctx context.Context, creds *remoteCredentials) error {
|
||||
func (s *DoltStore) doltCLIPull(ctx context.Context, remote string, creds *remoteCredentials) error {
|
||||
ctx, cancel := context.WithTimeout(ctx, cliExecTimeout)
|
||||
defer cancel()
|
||||
cmd := exec.CommandContext(ctx, "dolt", "pull", s.remote, s.branch) // #nosec G204 -- fixed command
|
||||
cmd := exec.CommandContext(ctx, "dolt", "pull", remote, s.branch) // #nosec G204 -- fixed command
|
||||
cmd.Dir = s.CLIDir()
|
||||
creds.applyToCmd(cmd)
|
||||
out, err := cmd.CombinedOutput()
|
||||
|
|
@ -1882,92 +1892,84 @@ func (s *DoltStore) doltCLIPull(ctx context.Context, creds *remoteCredentials) e
|
|||
// For non-SSH Hosted Dolt (remoteUser set), uses CALL DOLT_PUSH with --user authentication.
|
||||
// For other remotes (DoltHub, S3, GCS, file), uses CALL DOLT_PUSH via SQL.
|
||||
func (s *DoltStore) Push(ctx context.Context) (retErr error) {
|
||||
ctx, span := doltTracer.Start(ctx, "dolt.push",
|
||||
trace.WithSpanKind(trace.SpanKindClient),
|
||||
trace.WithAttributes(append(s.doltSpanAttrs(),
|
||||
attribute.String("dolt.remote", s.remote),
|
||||
attribute.String("dolt.branch", s.branch),
|
||||
)...),
|
||||
)
|
||||
defer func() { endSpan(span, retErr) }()
|
||||
creds := s.mainRemoteCredentials()
|
||||
// Git-protocol remotes: use CLI to avoid MySQL connection timeout during transfer.
|
||||
// Must check before remoteUser — Hosted Dolt SSH remotes have remoteUser set
|
||||
// but still need CLI to avoid SQL connection timeout.
|
||||
// Credentials are passed directly to the subprocess via cmd.Env, avoiding
|
||||
// process-wide env var races with concurrent goroutines.
|
||||
if s.isGitProtocolRemote(ctx) {
|
||||
return s.doltCLIPush(ctx, false, creds)
|
||||
}
|
||||
// Credential CLI routing: when credentials are set and server is external,
|
||||
// route through CLI subprocess so credentials reach the dolt process via
|
||||
// cmd.Env (applyToCmd). The SQL path's withEnvCredentials sets process-wide
|
||||
// env vars that an external server cannot see.
|
||||
if s.shouldUseCLIForCredentials(ctx) {
|
||||
return s.doltCLIPush(ctx, false, creds)
|
||||
}
|
||||
// Cloud auth CLI routing: when cloud storage env vars (AZURE_*, AWS_*,
|
||||
// etc.) are set and we're in server mode, route through CLI so the dolt
|
||||
// subprocess inherits the current env. The SQL server may not have these
|
||||
// vars if it was started in a different context (GH#6).
|
||||
if s.shouldUseCLIForCloudAuth() {
|
||||
return s.doltCLIPush(ctx, false, creds)
|
||||
}
|
||||
if s.remoteUser != "" {
|
||||
return withEnvCredentials(creds, func() error {
|
||||
if err := s.execWithLongTimeout(ctx, "CALL DOLT_PUSH('--user', ?, ?, ?)", s.remoteUser, s.remote, s.branch); err != nil {
|
||||
return fmt.Errorf("failed to push to %s/%s: %w", s.remote, s.branch, err)
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
if err := s.execWithLongTimeout(ctx, "CALL DOLT_PUSH(?, ?)", s.remote, s.branch); err != nil {
|
||||
return fmt.Errorf("failed to push to %s/%s: %w", s.remote, s.branch, err)
|
||||
}
|
||||
return nil
|
||||
return s.pushToRemote(ctx, s.remote, false)
|
||||
}
|
||||
|
||||
// ForcePush force-pushes commits to the remote, overwriting remote changes.
|
||||
// Use when the remote has uncommitted changes in its working set.
|
||||
// For git-protocol remotes (SSH, git+https://, git://), uses CLI `dolt push --force` to avoid MySQL connection timeouts.
|
||||
func (s *DoltStore) ForcePush(ctx context.Context) (retErr error) {
|
||||
ctx, span := doltTracer.Start(ctx, "dolt.force_push",
|
||||
return s.pushToRemote(ctx, s.remote, true)
|
||||
}
|
||||
|
||||
// PushRemote pushes commits to a named remote. Unlike Push(), which always
|
||||
// uses the configured default remote (s.remote), PushRemote targets an
|
||||
// explicit remote name. Credentials are only applied when the target remote
|
||||
// matches the default remote; otherwise nil creds are used.
|
||||
func (s *DoltStore) PushRemote(ctx context.Context, remote string, force bool) error {
|
||||
return s.pushToRemote(ctx, remote, force)
|
||||
}
|
||||
|
||||
// pushToRemote is the internal implementation for all push operations.
|
||||
// It routes through CLI or SQL based on the remote's protocol and credentials.
|
||||
func (s *DoltStore) pushToRemote(ctx context.Context, remote string, force bool) (retErr error) {
|
||||
spanName := "dolt.push"
|
||||
if force {
|
||||
spanName = "dolt.force_push"
|
||||
}
|
||||
ctx, span := doltTracer.Start(ctx, spanName,
|
||||
trace.WithSpanKind(trace.SpanKindClient),
|
||||
trace.WithAttributes(append(s.doltSpanAttrs(),
|
||||
attribute.String("dolt.remote", s.remote),
|
||||
attribute.String("dolt.remote", remote),
|
||||
attribute.String("dolt.branch", s.branch),
|
||||
)...),
|
||||
)
|
||||
defer func() { endSpan(span, retErr) }()
|
||||
creds := s.mainRemoteCredentials()
|
||||
creds := s.credentialsForRemote(remote)
|
||||
// Git-protocol remotes: use CLI to avoid MySQL connection timeout during transfer.
|
||||
// Must check before remoteUser — Hosted Dolt SSH remotes have remoteUser set
|
||||
// but still need CLI to avoid SQL connection timeout.
|
||||
// Credentials are passed directly to the subprocess via cmd.Env.
|
||||
if s.isGitProtocolRemote(ctx) {
|
||||
return s.doltCLIPush(ctx, true, creds)
|
||||
// Credentials are passed directly to the subprocess via cmd.Env, avoiding
|
||||
// process-wide env var races with concurrent goroutines.
|
||||
if s.isGitProtocolRemote(ctx, remote) {
|
||||
return s.doltCLIPush(ctx, remote, force, creds)
|
||||
}
|
||||
// Credential CLI routing: when credentials are set and server is external,
|
||||
// route through CLI subprocess so credentials reach the dolt process via
|
||||
// cmd.Env (applyToCmd). The SQL path's withEnvCredentials sets process-wide
|
||||
// env vars that an external server cannot see.
|
||||
if s.shouldUseCLIForCredentials(ctx) {
|
||||
return s.doltCLIPush(ctx, true, creds)
|
||||
if s.shouldUseCLIForCredentials(ctx, remote, creds) {
|
||||
return s.doltCLIPush(ctx, remote, force, creds)
|
||||
}
|
||||
// Cloud auth CLI routing (GH#6).
|
||||
if s.shouldUseCLIForCloudAuth() {
|
||||
return s.doltCLIPush(ctx, true, creds)
|
||||
// Cloud auth CLI routing: when cloud storage env vars (AZURE_*, AWS_*,
|
||||
// etc.) are set and we're in server mode, route through CLI so the dolt
|
||||
// subprocess inherits the current env. The SQL server may not have these
|
||||
// vars if it was started in a different context (GH#6).
|
||||
if s.shouldUseCLIForCloudAuth(remote) {
|
||||
return s.doltCLIPush(ctx, remote, force, creds)
|
||||
}
|
||||
if s.remoteUser != "" {
|
||||
if s.remoteUser != "" && remote == s.remote {
|
||||
return withEnvCredentials(creds, func() error {
|
||||
if err := s.execWithLongTimeout(ctx, "CALL DOLT_PUSH('--force', '--user', ?, ?, ?)", s.remoteUser, s.remote, s.branch); err != nil {
|
||||
return fmt.Errorf("failed to force push to %s/%s: %w", s.remote, s.branch, err)
|
||||
if force {
|
||||
if err := s.execWithLongTimeout(ctx, "CALL DOLT_PUSH('--force', '--user', ?, ?, ?)", s.remoteUser, remote, s.branch); err != nil {
|
||||
return fmt.Errorf("failed to force push to %s/%s: %w", remote, s.branch, err)
|
||||
}
|
||||
} else {
|
||||
if err := s.execWithLongTimeout(ctx, "CALL DOLT_PUSH('--user', ?, ?, ?)", s.remoteUser, remote, s.branch); err != nil {
|
||||
return fmt.Errorf("failed to push to %s/%s: %w", remote, s.branch, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
if err := s.execWithLongTimeout(ctx, "CALL DOLT_PUSH('--force', ?, ?)", s.remote, s.branch); err != nil {
|
||||
return fmt.Errorf("failed to force push to %s/%s: %w", s.remote, s.branch, err)
|
||||
if force {
|
||||
if err := s.execWithLongTimeout(ctx, "CALL DOLT_PUSH('--force', ?, ?)", remote, s.branch); err != nil {
|
||||
return fmt.Errorf("failed to force push to %s/%s: %w", remote, s.branch, err)
|
||||
}
|
||||
} else {
|
||||
if err := s.execWithLongTimeout(ctx, "CALL DOLT_PUSH(?, ?)", remote, s.branch); err != nil {
|
||||
return fmt.Errorf("failed to push to %s/%s: %w", remote, s.branch, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
|
@ -1981,10 +1983,24 @@ func (s *DoltStore) ForcePush(ctx context.Context) (retErr error) {
|
|||
// stale dolt_auto_push_* rows on multi-machine setups), the conflicts are
|
||||
// automatically resolved using "theirs" strategy (GH#2466).
|
||||
func (s *DoltStore) Pull(ctx context.Context) (retErr error) {
|
||||
return s.pullFromRemote(ctx, s.remote)
|
||||
}
|
||||
|
||||
// PullRemote pulls changes from a named remote. Unlike Pull(), which always
|
||||
// uses the configured default remote (s.remote), PullRemote targets an
|
||||
// explicit remote name. Credentials are only applied when the target remote
|
||||
// matches the default remote; otherwise nil creds are used.
|
||||
func (s *DoltStore) PullRemote(ctx context.Context, remote string) error {
|
||||
return s.pullFromRemote(ctx, remote)
|
||||
}
|
||||
|
||||
// pullFromRemote is the internal implementation for all pull operations.
|
||||
// It routes through CLI or SQL based on the remote's protocol and credentials.
|
||||
func (s *DoltStore) pullFromRemote(ctx context.Context, remote string) (retErr error) {
|
||||
ctx, span := doltTracer.Start(ctx, "dolt.pull",
|
||||
trace.WithSpanKind(trace.SpanKindClient),
|
||||
trace.WithAttributes(append(s.doltSpanAttrs(),
|
||||
attribute.String("dolt.remote", s.remote),
|
||||
attribute.String("dolt.remote", remote),
|
||||
attribute.String("dolt.branch", s.branch),
|
||||
)...),
|
||||
)
|
||||
|
|
@ -2003,13 +2019,13 @@ func (s *DoltStore) Pull(ctx context.Context) (retErr error) {
|
|||
}
|
||||
}
|
||||
|
||||
creds := s.mainRemoteCredentials()
|
||||
creds := s.credentialsForRemote(remote)
|
||||
// Git-protocol remotes: use CLI to avoid MySQL connection timeout during transfer.
|
||||
// Must check before remoteUser — Hosted Dolt SSH remotes have remoteUser set
|
||||
// but still need CLI to avoid SQL connection timeout.
|
||||
// Credentials are passed directly to the subprocess via cmd.Env.
|
||||
if s.isGitProtocolRemote(ctx) {
|
||||
if err := s.doltCLIPull(ctx, creds); err != nil {
|
||||
if s.isGitProtocolRemote(ctx, remote) {
|
||||
if err := s.doltCLIPull(ctx, remote, creds); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
|
|
@ -2017,26 +2033,26 @@ func (s *DoltStore) Pull(ctx context.Context) (retErr error) {
|
|||
// Credential CLI routing: mirrors git-protocol path.
|
||||
// Skips pullWithAutoResolve (consistent with git-protocol Pull — CLI manages its
|
||||
// own connections and conflict handling).
|
||||
if s.shouldUseCLIForCredentials(ctx) {
|
||||
if err := s.doltCLIPull(ctx, creds); err != nil {
|
||||
if s.shouldUseCLIForCredentials(ctx, remote, creds) {
|
||||
if err := s.doltCLIPull(ctx, remote, creds); err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
// Cloud auth CLI routing (GH#6).
|
||||
if s.shouldUseCLIForCloudAuth() {
|
||||
return s.doltCLIPull(ctx, creds)
|
||||
if s.shouldUseCLIForCloudAuth(remote) {
|
||||
return s.doltCLIPull(ctx, remote, creds)
|
||||
}
|
||||
if s.remoteUser != "" {
|
||||
if s.remoteUser != "" && remote == s.remote {
|
||||
return withEnvCredentials(creds, func() error {
|
||||
if err := s.pullWithAutoResolve(ctx, "CALL DOLT_PULL('--user', ?, ?, ?)", s.remoteUser, s.remote, s.branch); err != nil {
|
||||
return fmt.Errorf("failed to pull from %s/%s: %w", s.remote, s.branch, err)
|
||||
if err := s.pullWithAutoResolve(ctx, "CALL DOLT_PULL('--user', ?, ?, ?)", s.remoteUser, remote, s.branch); err != nil {
|
||||
return fmt.Errorf("failed to pull from %s/%s: %w", remote, s.branch, err)
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
if err := s.pullWithAutoResolve(ctx, "CALL DOLT_PULL(?, ?)", s.remote, s.branch); err != nil {
|
||||
return fmt.Errorf("failed to pull from %s/%s: %w", s.remote, s.branch, err)
|
||||
if err := s.pullWithAutoResolve(ctx, "CALL DOLT_PULL(?, ?)", remote, s.branch); err != nil {
|
||||
return fmt.Errorf("failed to pull from %s/%s: %w", remote, s.branch, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
|
|
|||
|
|
@ -231,6 +231,21 @@ func (s *EmbeddedDoltStore) ForcePush(ctx context.Context) error {
|
|||
})
|
||||
}
|
||||
|
||||
func (s *EmbeddedDoltStore) PushRemote(ctx context.Context, remote string, force bool) error {
|
||||
return s.withDBConn(ctx, func(db versioncontrolops.DBConn) error {
|
||||
if force {
|
||||
return versioncontrolops.ForcePush(ctx, db, remote, s.branch)
|
||||
}
|
||||
return versioncontrolops.Push(ctx, db, remote, s.branch)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *EmbeddedDoltStore) PullRemote(ctx context.Context, remote string) error {
|
||||
return s.withDBConn(ctx, func(db versioncontrolops.DBConn) error {
|
||||
return versioncontrolops.Pull(ctx, db, remote, s.branch)
|
||||
})
|
||||
}
|
||||
|
||||
func (s *EmbeddedDoltStore) Fetch(ctx context.Context, peer string) error {
|
||||
return s.withDBConn(ctx, func(db versioncontrolops.DBConn) error {
|
||||
return versioncontrolops.Fetch(ctx, db, peer)
|
||||
|
|
|
|||
|
|
@ -11,6 +11,8 @@ type RemoteStore interface {
|
|||
Push(ctx context.Context) error
|
||||
Pull(ctx context.Context) error
|
||||
ForcePush(ctx context.Context) error
|
||||
PushRemote(ctx context.Context, remote string, force bool) error
|
||||
PullRemote(ctx context.Context, remote string) error
|
||||
Fetch(ctx context.Context, peer string) error
|
||||
PushTo(ctx context.Context, peer string) error
|
||||
PullFrom(ctx context.Context, peer string) ([]Conflict, error)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue