# Deduplicate gitsync adapter wiring

`ee16e97`→[main](/content/gh/entireio/git-sync/commits/main/index.html)·

Soph·3mo ago·2 files·+64 added/-24 removed

## Sessions

80cdcddb4888View transcript

## Changes

2

- pkg/gitsync

- Mclient.go+47/-17

- unstable

- Mclient.go+17/-7

```
    77 unmodified lines
    
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    87
    88
    89
    90
    89
    90
    91
    92
    93
    94
    95
    1 unmodified line
    
    97
    98
    99
    98
    99
    100
    101
    102
    103
    104
    13 unmodified lines

118
    119
    120
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    121
    122
    123
    124
    125
    126
    127
    128
    129
    33 unmodified lines

163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    
    77 unmodified lines

if err != nil {
		return internalbridge.Config{}, err
	}
	source := bridgeEndpoint(req.Source)
	sourceResolved := bridgeEndpointAuth(sourceAuth)
	if req.Target != nil {
		targetAuth, err := c.authFor(ctx, *req.Target, TargetRole)
		if err != nil {
			return internalbridge.Config{}, err
		}
		return internalbridge.ProbeConfig(
			internalbridge.Endpoint{URL: req.Source.URL},
			internalbridge.EndpointAuth(sourceAuth),
			&internalbridge.Endpoint{URL: req.Target.URL},
			internalbridge.EndpointAuth(targetAuth),
			source,
			sourceResolved,
			ptr(bridgeEndpoint(*req.Target)),
			bridgeEndpointAuth(targetAuth),
			internalbridge.ProtocolMode(req.Protocol),
			req.IncludeTags,
			req.CollectStats,
		), nil
	}
	return internalbridge.ProbeConfig(
		internalbridge.Endpoint{URL: req.Source.URL},
		internalbridge.EndpointAuth(sourceAuth),
		source,
		sourceResolved,
		nil,
		internalbridge.EndpointAuth{},
		internalbridge.ProtocolMode(req.Protocol),
	)
}

return nil
}

func bridgeEndpoint(ep Endpoint) internalbridge.Endpoint {
	return internalbridge.Endpoint{URL: ep.URL}
}

func bridgeEndpointAuth(auth EndpointAuth) internalbridge.EndpointAuth {
	return internalbridge.EndpointAuth{
		Username:      auth.Username,
		Token:         auth.Token,
		BearerToken:   auth.BearerToken,
		SkipTLSVerify: auth.SkipTLSVerify,
	}
}

func bridgeScope(scope RefScope) internalbridge.RefScope {
	return internalbridge.RefScope{
		Branches: append([]string(nil), scope.Branches...),
		Mappings: append([]internalbridge.RefMapping(nil), scope.Mappings...),
	}
}

func bridgePolicy(policy SyncPolicy) internalbridge.SyncPolicy {
	return internalbridge.SyncPolicy{
		IncludeTags: policy.IncludeTags,
		Force:       policy.Force,
		Prune:       policy.Prune,
		Protocol:    internalbridge.ProtocolMode(policy.Protocol),
	}
}

func ptr[T any](v T) *T {
	return &v
}
```

Mpkg/gitsync/client.go+47/-17

```
126 unmodified lines

127
128
129
130
130
131
132
133
5 unmodified lines

139
140
141
142
142
143
144
145
12 unmodified lines

158
159
160
161
162
161
162
163
164
165
19 unmodified lines

185
186
187
188
189
188
189
190
191
192
13 unmodified lines

206
207
208
209
209
210
211
212
17 unmodified lines

230
231
232
233
234
235
236
237
238
239
240
241
242

126 unmodified lines

return syncer.Config{}, err
}
	cfg := syncer.Config{
		Source:        syncer.Endpoint{URL: req.Source.URL, Username: sourceAuth.Username, Token: sourceAuth.Token, BearerToken: sourceAuth.BearerToken, SkipTLSVerify: sourceAuth.SkipTLSVerify},
		Source:        syncerEndpoint(req.Source, sourceAuth),
		HTTPClient:    c.httpClient,
		IncludeTags:   req.IncludeTags,
		ShowStats:     req.Options.CollectStats,
	5 unmodified lines

if err != nil {
			return syncer.Config{}, err
		}
		cfg.Target = syncer.Endpoint{URL: req.Target.URL, Username: targetAuth.Username, Token: targetAuth.Token, BearerToken: targetAuth.BearerToken, SkipTLSVerify: targetAuth.SkipTLSVerify}
		cfg.Target = syncerEndpoint(*req.Target, targetAuth)
	}
	return cfg, nil
}
12 unmodified lines

maxObjects = DefaultMaterializedMaxObjects
}
return syncer.Config{
	Source:                 syncer.Endpoint{URL: req.Source.URL, Username: sourceAuth.Username, Token: sourceAuth.Token, BearerToken: sourceAuth.BearerToken, SkipTLSVerify: sourceAuth.SkipTLSVerify},
	Target:                 syncer.Endpoint{URL: req.Target.URL, Username: targetAuth.Username, Token: targetAuth.Token, BearerToken: targetAuth.BearerToken, SkipTLSVerify: targetAuth.SkipTLSVerify},
	Source:                 syncerEndpoint(req.Source, sourceAuth),
	Target:                 syncerEndpoint(req.Target, targetAuth),
	HTTPClient:             c.httpClient,
	Branches:               append([]string(nil), req.Scope.Branches...),
	Mappings:               append([]gitsync.RefMapping(nil), req.Scope.Mappings...),
19 unmodified lines

return syncer.Config{}, err
}
return syncer.Config{
	Source:            syncer.Endpoint{URL: req.Source.URL, Username: sourceAuth.Username, Token: sourceAuth.Token, BearerToken: sourceAuth.BearerToken, SkipTLSVerify: sourceAuth.SkipTLSVerify},
	Target:            syncer.Endpoint{URL: req.Target.URL, Username: targetAuth.Username, Token: targetAuth.Token, BearerToken: targetAuth.BearerToken, SkipTLSVerify: targetAuth.SkipTLSVerify},
	Source:            syncerEndpoint(req.Source, sourceAuth),
	Target:            syncerEndpoint(req.Target, targetAuth),
	HTTPClient:        c.httpClient,
	Branches:          append([]string(nil), req.Scope.Branches...),
	Mappings:          append([]gitsync.RefMapping(nil), req.Scope.Mappings...),
13 unmodified lines

return syncer.Config{}, err
}
return syncer.Config{
	Source:        syncer.Endpoint{URL: req.Source.URL, Username: sourceAuth.Username, Token: sourceAuth.Token, BearerToken: sourceAuth.BearerToken, SkipTLSVerify: sourceAuth.SkipTLSVerify},
	Source:        syncerEndpoint(req.Source, sourceAuth),
	HTTPClient:    c.httpClient,
	Branches:      append([]string(nil), req.Scope.Branches...)
	IncludeTags:   req.IncludeTags,
17 unmodified lines

}
return string(mode)
}

func syncerEndpoint(endpoint gitsync.Endpoint, auth gitsync.EndpointAuth) syncer.Endpoint {
	return syncer.Endpoint{
		URL:           endpoint.URL,
		Username:      auth.Username,
		Token:         auth.Token,
		BearerToken:   auth.BearerToken,
		SkipTLSVerify: auth.SkipTLSVerify,
	}
}
```

Mpkg/gitsync/unstable/client.go+17/-7