+3

appview/oauth/oauth.go

··· 286 286 AccessJwt: resp.Token, 287 287 }, 288 288 Host: opts.Host(), 289 289 + Client: &http.Client{ 290 290 + Timeout: time.Second * 5, 291 291 + }, 289 292 }, nil 290 293 } 291 294

+8 -8

appview/pages/pages.go

··· 531 531 } 532 532 533 533 type RepoIndexParams struct { 534 534 - LoggedInUser *oauth.User 535 535 - RepoInfo repoinfo.RepoInfo 536 536 - Active string 537 537 - TagMap map[string][]string 538 538 - CommitsTrunc []*object.Commit 539 539 - TagsTrunc []*types.TagReference 540 540 - BranchesTrunc []types.Branch 541 541 - ForkInfo *types.ForkInfo 534 534 + LoggedInUser *oauth.User 535 535 + RepoInfo repoinfo.RepoInfo 536 536 + Active string 537 537 + TagMap map[string][]string 538 538 + CommitsTrunc []*object.Commit 539 539 + TagsTrunc []*types.TagReference 540 540 + BranchesTrunc []types.Branch 541 541 + // ForkInfo *types.ForkInfo 542 542 HTMLReadme template.HTML 543 543 Raw bool 544 544 EmailToDidOrHandle map[string]string

-33

appview/pages/templates/repo/index.html

··· 84 84 </optgroup> 85 85 </select> 86 86 <div class="flex items-center gap-2"> 87 87 - {{ $isOwner := and .LoggedInUser .RepoInfo.Roles.IsOwner }} 88 88 - {{ $isCollaborator := and .LoggedInUser .RepoInfo.Roles.IsCollaborator }} 89 89 - {{ if and (or $isOwner $isCollaborator) .ForkInfo .ForkInfo.IsFork }} 90 90 - {{ $disabled := "" }} 91 91 - {{ $title := "" }} 92 92 - {{ if eq .ForkInfo.Status 0 }} 93 93 - {{ $disabled = "disabled" }} 94 94 - {{ $title = "This branch is not behind the upstream" }} 95 95 - {{ else if eq .ForkInfo.Status 2 }} 96 96 - {{ $disabled = "disabled" }} 97 97 - {{ $title = "This branch has conflicts that must be resolved" }} 98 98 - {{ else if eq .ForkInfo.Status 3 }} 99 99 - {{ $disabled = "disabled" }} 100 100 - {{ $title = "This branch does not exist on the upstream" }} 101 101 - {{ end }} 102 102 - 103 103 - <button 104 104 - id="syncBtn" 105 105 - {{ $disabled }} 106 106 - {{ if $title }}title="{{ $title }}"{{ end }} 107 107 - class="btn flex gap-2 items-center disabled:opacity-50 disabled:cursor-not-allowed" 108 108 - hx-post="/{{ .RepoInfo.FullName }}/fork/sync" 109 109 - hx-trigger="click" 110 110 - hx-swap="none" 111 111 - > 112 112 - {{ if $disabled }} 113 113 - {{ i "refresh-cw-off" "w-4 h-4" }} 114 114 - {{ else }} 115 115 - {{ i "refresh-cw" "w-4 h-4" }} 116 116 - {{ end }} 117 117 - <span>sync</span> 118 118 - </button> 119 119 - {{ end }} 120 87 <a 121 88 href="/{{ .RepoInfo.FullName }}/compare?base={{ $.Ref | urlquery }}" 122 89 class="btn flex items-center gap-2 no-underline hover:no-underline"

+163 -120

appview/repo/index.go

··· 1 1 package repo 2 2 3 3 import ( 4 4 - "encoding/json" 5 5 - "fmt" 6 4 "log" 7 5 "net/http" 8 6 "slices" ··· 11 9 12 10 "tangled.sh/tangled.sh/core/appview/commitverify" 13 11 "tangled.sh/tangled.sh/core/appview/db" 14 14 - "tangled.sh/tangled.sh/core/appview/oauth" 15 12 "tangled.sh/tangled.sh/core/appview/pages" 16 16 - "tangled.sh/tangled.sh/core/appview/pages/repoinfo" 17 13 "tangled.sh/tangled.sh/core/appview/reporesolver" 18 14 "tangled.sh/tangled.sh/core/knotclient" 19 15 "tangled.sh/tangled.sh/core/types" ··· 105 101 user := rp.oauth.GetUser(r) 106 102 repoInfo := f.RepoInfo(user) 107 103 108 108 - secret, err := db.GetRegistrationKey(rp.db, f.Knot) 109 109 - if err != nil { 110 110 - log.Printf("failed to get registration key for %s: %s", f.Knot, err) 111 111 - rp.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") 112 112 - } 104 104 + // secret, err := db.GetRegistrationKey(rp.db, f.Knot) 105 105 + // if err != nil { 106 106 + // log.Printf("failed to get registration key for %s: %s", f.Knot, err) 107 107 + // rp.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.") 108 108 + // } 113 109 114 114 - signedClient, err := knotclient.NewSignedClient(f.Knot, secret, rp.config.Core.Dev) 115 115 - if err != nil { 116 116 - log.Printf("failed to create signed client for %s: %s", f.Knot, err) 117 117 - return 118 118 - } 110 110 + // signedClient, err := knotclient.NewSignedClient(f.Knot, secret, rp.config.Core.Dev) 111 111 + // if err != nil { 112 112 + // log.Printf("failed to create signed client for %s: %s", f.Knot, err) 113 113 + // return 114 114 + // } 119 115 120 120 - var forkInfo *types.ForkInfo 121 121 - if user != nil && (repoInfo.Roles.IsOwner() || repoInfo.Roles.IsCollaborator()) { 122 122 - forkInfo, err = getForkInfo(r, repoInfo, rp, f, result.Ref, user, signedClient) 123 123 - if err != nil { 124 124 - log.Printf("Failed to fetch fork information: %v", err) 125 125 - return 126 126 - } 127 127 - } 116 116 + // var forkInfo *types.ForkInfo 117 117 + // if user != nil && (repoInfo.Roles.IsOwner() || repoInfo.Roles.IsCollaborator()) { 118 118 + // forkInfo, err = getForkInfo(r, repoInfo, rp, f, result.Ref, user, signedClient) 119 119 + // if err != nil { 120 120 + // log.Printf("Failed to fetch fork information: %v", err) 121 121 + // return 122 122 + // } 123 123 + // } 128 124 129 125 // TODO: a bit dirty 130 130 - languageInfo, err := rp.getLanguageInfo(f, signedClient, result.Ref, ref == "") 126 126 + languageInfo, err := rp.getLanguageInfo(f, us, result.Ref, ref == "") 131 127 if err != nil { 132 128 log.Printf("failed to compute language percentages: %s", err) 133 129 // non-fatal ··· 144 140 } 145 141 146 142 rp.pages.RepoIndexPage(w, pages.RepoIndexParams{ 147 147 - LoggedInUser: user, 148 148 - RepoInfo: repoInfo, 149 149 - TagMap: tagMap, 150 150 - RepoIndexResponse: *result, 151 151 - CommitsTrunc: commitsTrunc, 152 152 - TagsTrunc: tagsTrunc, 153 153 - ForkInfo: forkInfo, 143 143 + LoggedInUser: user, 144 144 + RepoInfo: repoInfo, 145 145 + TagMap: tagMap, 146 146 + RepoIndexResponse: *result, 147 147 + CommitsTrunc: commitsTrunc, 148 148 + TagsTrunc: tagsTrunc, 149 149 + // ForkInfo: forkInfo, // TODO: reinstate this after xrpc properly lands 154 150 BranchesTrunc: branchesTrunc, 155 151 EmailToDidOrHandle: emailToDidOrHandle(rp, emailToDidMap), 156 152 VerifiedCommits: vc, ··· 161 157 162 158 func (rp *Repo) getLanguageInfo( 163 159 f *reporesolver.ResolvedRepo, 164 164 - signedClient *knotclient.SignedClient, 160 160 + us *knotclient.UnsignedClient, 165 161 currentRef string, 166 162 isDefaultRef bool, 167 163 ) ([]types.RepoLanguageDetails, error) { ··· 174 170 175 171 if err != nil || langs == nil { 176 172 // non-fatal, fetch langs from ks 177 177 - ls, err := signedClient.RepoLanguages(f.OwnerDid(), f.Name, currentRef) 173 173 + ls, err := us.RepoLanguages(f.OwnerDid(), f.Name, currentRef) 178 174 if err != nil { 179 175 return nil, err 180 176 } ··· 232 228 return languageStats, nil 233 229 } 234 230 235 235 - func getForkInfo( 236 236 - r *http.Request, 237 237 - repoInfo repoinfo.RepoInfo, 238 238 - rp *Repo, 239 239 - f *reporesolver.ResolvedRepo, 240 240 - currentRef string, 241 241 - user *oauth.User, 242 242 - signedClient *knotclient.SignedClient, 243 243 - ) (*types.ForkInfo, error) { 244 244 - if user == nil { 245 245 - return nil, nil 246 246 - } 247 247 - 248 248 - forkInfo := types.ForkInfo{ 249 249 - IsFork: repoInfo.Source != nil, 250 250 - Status: types.UpToDate, 251 251 - } 252 252 - 253 253 - if !forkInfo.IsFork { 254 254 - forkInfo.IsFork = false 255 255 - return &forkInfo, nil 256 256 - } 257 257 - 258 258 - us, err := knotclient.NewUnsignedClient(repoInfo.Source.Knot, rp.config.Core.Dev) 259 259 - if err != nil { 260 260 - log.Printf("failed to create unsigned client for %s", repoInfo.Source.Knot) 261 261 - return nil, err 262 262 - } 263 263 - 264 264 - result, err := us.Branches(repoInfo.Source.Did, repoInfo.Source.Name) 265 265 - if err != nil { 266 266 - log.Println("failed to reach knotserver", err) 267 267 - return nil, err 268 268 - } 269 269 - 270 270 - if !slices.ContainsFunc(result.Branches, func(branch types.Branch) bool { 271 271 - return branch.Name == currentRef 272 272 - }) { 273 273 - forkInfo.Status = types.MissingBranch 274 274 - return &forkInfo, nil 275 275 - } 276 276 - 277 277 - client, err := rp.oauth.ServiceClient( 278 278 - r, 279 279 - oauth.WithService(f.Knot), 280 280 - oauth.WithLxm(tangled.RepoHiddenRefNSID), 281 281 - oauth.WithDev(rp.config.Core.Dev), 282 282 - ) 283 283 - if err != nil { 284 284 - log.Printf("failed to connect to knot server: %v", err) 285 285 - return nil, err 286 286 - } 287 287 - 288 288 - resp, err := tangled.RepoHiddenRef( 289 289 - r.Context(), 290 290 - client, 291 291 - &tangled.RepoHiddenRef_Input{ 292 292 - ForkRef: currentRef, 293 293 - RemoteRef: currentRef, 294 294 - Repo: f.RepoAt().String(), 295 295 - }, 296 296 - ) 297 297 - if err != nil || !resp.Success { 298 298 - if err != nil { 299 299 - log.Printf("failed to update tracking branch: %s", err) 300 300 - } else { 301 301 - log.Printf("failed to update tracking branch: success=false") 302 302 - } 303 303 - return nil, fmt.Errorf("failed to update tracking branch") 304 304 - } 305 305 - 306 306 - hiddenRef := fmt.Sprintf("hidden/%s/%s", currentRef, currentRef) 307 307 - 308 308 - var status types.AncestorCheckResponse 309 309 - forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt()), repoInfo.Name, currentRef, hiddenRef) 310 310 - if err != nil { 311 311 - log.Printf("failed to check if fork is ahead/behind: %s", err) 312 312 - return nil, err 313 313 - } 314 314 - 315 315 - if err := json.NewDecoder(forkSyncableResp.Body).Decode(&status); err != nil { 316 316 - log.Printf("failed to decode fork status: %s", err) 317 317 - return nil, err 318 318 - } 319 319 - 320 320 - forkInfo.Status = status.Status 321 321 - return &forkInfo, nil 322 322 - } 231 231 + // func getForkInfo( 232 232 + // r *http.Request, 233 233 + // repoInfo repoinfo.RepoInfo, 234 234 + // rp *Repo, 235 235 + // f *reporesolver.ResolvedRepo, 236 236 + // currentRef string, 237 237 + // user *oauth.User, 238 238 + // signedClient *knotclient.SignedClient, 239 239 + // ) (*types.ForkInfo, error) { 240 240 + // if user == nil { 241 241 + // return nil, nil 242 242 + // } 243 243 + // 244 244 + // forkInfo := types.ForkInfo{ 245 245 + // IsFork: repoInfo.Source != nil, 246 246 + // Status: types.UpToDate, 247 247 + // } 248 248 + // 249 249 + // if !forkInfo.IsFork { 250 250 + // forkInfo.IsFork = false 251 251 + // return &forkInfo, nil 252 252 + // } 253 253 + // 254 254 + // us, err := knotclient.NewUnsignedClient(repoInfo.Source.Knot, rp.config.Core.Dev) 255 255 + // if err != nil { 256 256 + // log.Printf("failed to create unsigned client for %s", repoInfo.Source.Knot) 257 257 + // return nil, err 258 258 + // } 259 259 + // 260 260 + // result, err := us.Branches(repoInfo.Source.Did, repoInfo.Source.Name) 261 261 + // if err != nil { 262 262 + // log.Println("failed to reach knotserver", err) 263 263 + // return nil, err 264 264 + // } 265 265 + // 266 266 + // if !slices.ContainsFunc(result.Branches, func(branch types.Branch) bool { 267 267 + // return branch.Name == currentRef 268 268 + // }) { 269 269 + // forkInfo.Status = types.MissingBranch 270 270 + // return &forkInfo, nil 271 271 + // } 272 272 + // 273 273 + // <<<<<<< Conflict 1 of 2 274 274 + // %%%%%%% Changes from base #1 to side #1 275 275 + // client, err := rp.oauth.ServiceClient( 276 276 + // r, 277 277 + // oauth.WithService(f.Knot), 278 278 + // oauth.WithLxm(tangled.RepoHiddenRefNSID), 279 279 + // oauth.WithDev(rp.config.Core.Dev), 280 280 + // ) 281 281 + // if err != nil { 282 282 + // log.Printf("failed to connect to knot server: %v", err) 283 283 + // %%%%%%% Changes from base #2 to side #2 284 284 + // - newHiddenRefResp, err := signedClient.NewHiddenRef(user.Did, repoInfo.Name, currentRef, currentRef) 285 285 + // + newHiddenRefResp, err := signedClient.NewHiddenRef(user.Did, repoInfo.Name, f.Ref, f.Ref) 286 286 + // if err != nil || newHiddenRefResp.StatusCode != http.StatusNoContent { 287 287 + // log.Printf("failed to update tracking branch: %s", err) 288 288 + // +++++++ Contents of side #3 289 289 + // client, err := rp.oauth.ServiceClient( 290 290 + // r, 291 291 + // oauth.WithService(f.Knot), 292 292 + // oauth.WithLxm(tangled.RepoHiddenRefNSID), 293 293 + // oauth.WithDev(rp.config.Core.Dev), 294 294 + // ) 295 295 + // if err != nil { 296 296 + // log.Printf("failed to connect to knot server: %v", err) 297 297 + // >>>>>>> Conflict 1 of 2 ends 298 298 + // return nil, err 299 299 + // } 300 300 + // 301 301 + // <<<<<<< Conflict 2 of 2 302 302 + // %%%%%%% Changes from base #1 to side #1 303 303 + // resp, err := tangled.RepoHiddenRef( 304 304 + // r.Context(), 305 305 + // client, 306 306 + // &tangled.RepoHiddenRef_Input{ 307 307 + // - ForkRef: f.Ref, 308 308 + // - RemoteRef: f.Ref, 309 309 + // + ForkRef: currentRef, 310 310 + // + RemoteRef: currentRef, 311 311 + // Repo: f.RepoAt().String(), 312 312 + // }, 313 313 + // ) 314 314 + // if err != nil || !resp.Success { 315 315 + // if err != nil { 316 316 + // log.Printf("failed to update tracking branch: %s", err) 317 317 + // } else { 318 318 + // log.Printf("failed to update tracking branch: success=false") 319 319 + // } 320 320 + // return nil, fmt.Errorf("failed to update tracking branch") 321 321 + // } 322 322 + // 323 323 + // - hiddenRef := fmt.Sprintf("hidden/%s/%s", f.Ref, f.Ref) 324 324 + // + hiddenRef := fmt.Sprintf("hidden/%s/%s", currentRef, currentRef) 325 325 + // 326 326 + // %%%%%%% Changes from base #2 to side #2 327 327 + // - hiddenRef := fmt.Sprintf("hidden/%s/%s", currentRef, currentRef) 328 328 + // + hiddenRef := fmt.Sprintf("hidden/%s/%s", f.Ref, f.Ref) 329 329 + // 330 330 + // +++++++ Contents of side #3 331 331 + // resp, err := tangled.RepoHiddenRef( 332 332 + // r.Context(), 333 333 + // client, 334 334 + // &tangled.RepoHiddenRef_Input{ 335 335 + // ForkRef: currentRef, 336 336 + // RemoteRef: currentRef, 337 337 + // Repo: f.RepoAt().String(), 338 338 + // }, 339 339 + // ) 340 340 + // if err != nil || !resp.Success { 341 341 + // if err != nil { 342 342 + // log.Printf("failed to update tracking branch: %s", err) 343 343 + // } else { 344 344 + // log.Printf("failed to update tracking branch: success=false") 345 345 + // } 346 346 + // return nil, fmt.Errorf("failed to update tracking branch") 347 347 + // } 348 348 + // 349 349 + // hiddenRef := fmt.Sprintf("hidden/%s/%s", currentRef, currentRef) 350 350 + // >>>>>>> Conflict 2 of 2 ends 351 351 + // var status types.AncestorCheckResponse 352 352 + // forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt()), repoInfo.Name, currentRef, hiddenRef) 353 353 + // if err != nil { 354 354 + // log.Printf("failed to check if fork is ahead/behind: %s", err) 355 355 + // return nil, err 356 356 + // } 357 357 + // 358 358 + // if err := json.NewDecoder(forkSyncableResp.Body).Decode(&status); err != nil { 359 359 + // log.Printf("failed to decode fork status: %s", err) 360 360 + // return nil, err 361 361 + // } 362 362 + // 363 363 + // forkInfo.Status = status.Status 364 364 + // return &forkInfo, nil 365 365 + // }