appview: disable fork syncing temporarily

this will return in the future

Signed-off-by: oppiliappan <[e-mail]>

appview/oauth/oauth.go

···
 			AccessJwt: resp.Token,
 		},
 		Host: opts.Host(),
+		Client: &http.Client{
+			Timeout: time.Second * 5,
+		},
 	}, nil
 }
 

appview/pages/pages.go

···
 }
 
 type RepoIndexParams struct {
-	LoggedInUser       *oauth.User
-	RepoInfo           repoinfo.RepoInfo
-	Active             string
-	TagMap             map[string][]string
-	CommitsTrunc       []*object.Commit
-	TagsTrunc          []*types.TagReference
-	BranchesTrunc      []types.Branch
-	ForkInfo           *types.ForkInfo
+	LoggedInUser  *oauth.User
+	RepoInfo      repoinfo.RepoInfo
+	Active        string
+	TagMap        map[string][]string
+	CommitsTrunc  []*object.Commit
+	TagsTrunc     []*types.TagReference
+	BranchesTrunc []types.Branch
+	// ForkInfo           *types.ForkInfo
 	HTMLReadme         template.HTML
 	Raw                bool
 	EmailToDidOrHandle map[string]string

appview/pages/templates/repo/index.html

···
           </optgroup>
       </select>
       <div class="flex items-center gap-2">
-    {{ $isOwner := and .LoggedInUser .RepoInfo.Roles.IsOwner }}
-    {{ $isCollaborator := and .LoggedInUser .RepoInfo.Roles.IsCollaborator }}
-    {{ if and (or $isOwner $isCollaborator) .ForkInfo .ForkInfo.IsFork }}
-        {{ $disabled := "" }}
-        {{ $title := "" }}
-        {{ if eq .ForkInfo.Status 0 }}
-            {{ $disabled = "disabled" }}
-            {{ $title = "This branch is not behind the upstream" }}
-        {{ else if eq .ForkInfo.Status 2 }}
-            {{ $disabled = "disabled" }}
-            {{ $title = "This branch has conflicts that must be resolved" }}
-        {{ else if eq .ForkInfo.Status 3 }}
-            {{ $disabled = "disabled" }}
-            {{ $title = "This branch does not exist on the upstream" }}
-        {{ end }}
-
-        <button
-            id="syncBtn"
-            {{ $disabled }}
-            {{ if $title }}title="{{ $title }}"{{ end }}
-            class="btn flex gap-2 items-center disabled:opacity-50 disabled:cursor-not-allowed"
-            hx-post="/{{ .RepoInfo.FullName }}/fork/sync"
-            hx-trigger="click"
-            hx-swap="none"
-        >
-          {{ if $disabled }}
-              {{ i "refresh-cw-off" "w-4 h-4" }}
-          {{ else }}
-              {{ i "refresh-cw" "w-4 h-4" }}
-          {{ end }}
-          <span>sync</span>
-        </button>
-    {{ end }}
           <a
               href="/{{ .RepoInfo.FullName }}/compare?base={{ $.Ref | urlquery }}"
               class="btn flex items-center gap-2 no-underline hover:no-underline"

appview/repo/index.go

···
 package repo
 
 import (
-	"encoding/json"
-	"fmt"
 	"log"
 	"net/http"
 	"slices"
···
 
 	"tangled.sh/tangled.sh/core/appview/commitverify"
 	"tangled.sh/tangled.sh/core/appview/db"
-	"tangled.sh/tangled.sh/core/appview/oauth"
 	"tangled.sh/tangled.sh/core/appview/pages"
-	"tangled.sh/tangled.sh/core/appview/pages/repoinfo"
 	"tangled.sh/tangled.sh/core/appview/reporesolver"
 	"tangled.sh/tangled.sh/core/knotclient"
 	"tangled.sh/tangled.sh/core/types"
···
 	user := rp.oauth.GetUser(r)
 	repoInfo := f.RepoInfo(user)
 
-	secret, err := db.GetRegistrationKey(rp.db, f.Knot)
-	if err != nil {
-		log.Printf("failed to get registration key for %s: %s", f.Knot, err)
-		rp.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
-	}
+	// secret, err := db.GetRegistrationKey(rp.db, f.Knot)
+	// if err != nil {
+	// 	log.Printf("failed to get registration key for %s: %s", f.Knot, err)
+	// 	rp.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
+	// }
 
-	signedClient, err := knotclient.NewSignedClient(f.Knot, secret, rp.config.Core.Dev)
-	if err != nil {
-		log.Printf("failed to create signed client for %s: %s", f.Knot, err)
-		return
-	}
+	// signedClient, err := knotclient.NewSignedClient(f.Knot, secret, rp.config.Core.Dev)
+	// if err != nil {
+	// 	log.Printf("failed to create signed client for %s: %s", f.Knot, err)
+	// 	return
+	// }
 
-	var forkInfo *types.ForkInfo
-	if user != nil && (repoInfo.Roles.IsOwner() || repoInfo.Roles.IsCollaborator()) {
-		forkInfo, err = getForkInfo(r, repoInfo, rp, f, result.Ref, user, signedClient)
-		if err != nil {
-			log.Printf("Failed to fetch fork information: %v", err)
-			return
-		}
-	}
+	// 	var forkInfo *types.ForkInfo
+	// 	if user != nil && (repoInfo.Roles.IsOwner() || repoInfo.Roles.IsCollaborator()) {
+	//		forkInfo, err = getForkInfo(r, repoInfo, rp, f, result.Ref, user, signedClient)
+	// 		if err != nil {
+	// 			log.Printf("Failed to fetch fork information: %v", err)
+	// 			return
+	// 		}
+	// 	}
 
 	// TODO: a bit dirty
-	languageInfo, err := rp.getLanguageInfo(f, signedClient, result.Ref, ref == "")
+	languageInfo, err := rp.getLanguageInfo(f, us, result.Ref, ref == "")
 	if err != nil {
 		log.Printf("failed to compute language percentages: %s", err)
 		// non-fatal
···
 	}
 
 	rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
-		LoggedInUser:       user,
-		RepoInfo:           repoInfo,
-		TagMap:             tagMap,
-		RepoIndexResponse:  *result,
-		CommitsTrunc:       commitsTrunc,
-		TagsTrunc:          tagsTrunc,
-		ForkInfo:           forkInfo,
+		LoggedInUser:      user,
+		RepoInfo:          repoInfo,
+		TagMap:            tagMap,
+		RepoIndexResponse: *result,
+		CommitsTrunc:      commitsTrunc,
+		TagsTrunc:         tagsTrunc,
+		// ForkInfo:           forkInfo, // TODO: reinstate this after xrpc properly lands
 		BranchesTrunc:      branchesTrunc,
 		EmailToDidOrHandle: emailToDidOrHandle(rp, emailToDidMap),
 		VerifiedCommits:    vc,
···
 
 func (rp *Repo) getLanguageInfo(
 	f *reporesolver.ResolvedRepo,
-	signedClient *knotclient.SignedClient,
+	us *knotclient.UnsignedClient,
 	currentRef string,
 	isDefaultRef bool,
 ) ([]types.RepoLanguageDetails, error) {
···
 
 	if err != nil || langs == nil {
 		// non-fatal, fetch langs from ks
-		ls, err := signedClient.RepoLanguages(f.OwnerDid(), f.Name, currentRef)
+		ls, err := us.RepoLanguages(f.OwnerDid(), f.Name, currentRef)
 		if err != nil {
 			return nil, err
 		}
···
 	return languageStats, nil
 }
 
-func getForkInfo(
-	r *http.Request,
-	repoInfo repoinfo.RepoInfo,
-	rp *Repo,
-	f *reporesolver.ResolvedRepo,
-	currentRef string,
-	user *oauth.User,
-	signedClient *knotclient.SignedClient,
-) (*types.ForkInfo, error) {
-	if user == nil {
-		return nil, nil
-	}
-
-	forkInfo := types.ForkInfo{
-		IsFork: repoInfo.Source != nil,
-		Status: types.UpToDate,
-	}
-
-	if !forkInfo.IsFork {
-		forkInfo.IsFork = false
-		return &forkInfo, nil
-	}
-
-	us, err := knotclient.NewUnsignedClient(repoInfo.Source.Knot, rp.config.Core.Dev)
-	if err != nil {
-		log.Printf("failed to create unsigned client for %s", repoInfo.Source.Knot)
-		return nil, err
-	}
-
-	result, err := us.Branches(repoInfo.Source.Did, repoInfo.Source.Name)
-	if err != nil {
-		log.Println("failed to reach knotserver", err)
-		return nil, err
-	}
-
-	if !slices.ContainsFunc(result.Branches, func(branch types.Branch) bool {
-		return branch.Name == currentRef
-	}) {
-		forkInfo.Status = types.MissingBranch
-		return &forkInfo, nil
-	}
-
-	client, err := rp.oauth.ServiceClient(
-		r,
-		oauth.WithService(f.Knot),
-		oauth.WithLxm(tangled.RepoHiddenRefNSID),
-		oauth.WithDev(rp.config.Core.Dev),
-	)
-	if err != nil {
-		log.Printf("failed to connect to knot server: %v", err)
-		return nil, err
-	}
-
-	resp, err := tangled.RepoHiddenRef(
-		r.Context(),
-		client,
-		&tangled.RepoHiddenRef_Input{
-			ForkRef:   currentRef,
-			RemoteRef: currentRef,
-			Repo:      f.RepoAt().String(),
-		},
-	)
-	if err != nil || !resp.Success {
-		if err != nil {
-			log.Printf("failed to update tracking branch: %s", err)
-		} else {
-			log.Printf("failed to update tracking branch: success=false")
-		}
-		return nil, fmt.Errorf("failed to update tracking branch")
-	}
-
-	hiddenRef := fmt.Sprintf("hidden/%s/%s", currentRef, currentRef)
-
-	var status types.AncestorCheckResponse
-	forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt()), repoInfo.Name, currentRef, hiddenRef)
-	if err != nil {
-		log.Printf("failed to check if fork is ahead/behind: %s", err)
-		return nil, err
-	}
-
-	if err := json.NewDecoder(forkSyncableResp.Body).Decode(&status); err != nil {
-		log.Printf("failed to decode fork status: %s", err)
-		return nil, err
-	}
-
-	forkInfo.Status = status.Status
-	return &forkInfo, nil
-}
+// func getForkInfo(
+// 	r *http.Request,
+// 	repoInfo repoinfo.RepoInfo,
+// 	rp *Repo,
+// 	f *reporesolver.ResolvedRepo,
+// 	currentRef string,
+// 	user *oauth.User,
+// 	signedClient *knotclient.SignedClient,
+// ) (*types.ForkInfo, error) {
+// 	if user == nil {
+// 		return nil, nil
+// 	}
+//
+// 	forkInfo := types.ForkInfo{
+// 		IsFork: repoInfo.Source != nil,
+// 		Status: types.UpToDate,
+// 	}
+//
+// 	if !forkInfo.IsFork {
+// 		forkInfo.IsFork = false
+// 		return &forkInfo, nil
+// 	}
+//
+// 	us, err := knotclient.NewUnsignedClient(repoInfo.Source.Knot, rp.config.Core.Dev)
+// 	if err != nil {
+// 		log.Printf("failed to create unsigned client for %s", repoInfo.Source.Knot)
+// 		return nil, err
+// 	}
+//
+// 	result, err := us.Branches(repoInfo.Source.Did, repoInfo.Source.Name)
+// 	if err != nil {
+// 		log.Println("failed to reach knotserver", err)
+// 		return nil, err
+// 	}
+//
+// 	if !slices.ContainsFunc(result.Branches, func(branch types.Branch) bool {
+// 		return branch.Name == currentRef
+// 	}) {
+// 		forkInfo.Status = types.MissingBranch
+// 		return &forkInfo, nil
+// 	}
+//
+// <<<<<<< Conflict 1 of 2
+// %%%%%%% Changes from base #1 to side #1
+//  	client, err := rp.oauth.ServiceClient(
+//  		r,
+//  		oauth.WithService(f.Knot),
+//  		oauth.WithLxm(tangled.RepoHiddenRefNSID),
+//  		oauth.WithDev(rp.config.Core.Dev),
+//  	)
+//  	if err != nil {
+//  		log.Printf("failed to connect to knot server: %v", err)
+// %%%%%%% Changes from base #2 to side #2
+// -	newHiddenRefResp, err := signedClient.NewHiddenRef(user.Did, repoInfo.Name, currentRef, currentRef)
+// +	newHiddenRefResp, err := signedClient.NewHiddenRef(user.Did, repoInfo.Name, f.Ref, f.Ref)
+//  	if err != nil || newHiddenRefResp.StatusCode != http.StatusNoContent {
+//  		log.Printf("failed to update tracking branch: %s", err)
+// +++++++ Contents of side #3
+// 	client, err := rp.oauth.ServiceClient(
+// 		r,
+// 		oauth.WithService(f.Knot),
+// 		oauth.WithLxm(tangled.RepoHiddenRefNSID),
+// 		oauth.WithDev(rp.config.Core.Dev),
+// 	)
+// 	if err != nil {
+// 		log.Printf("failed to connect to knot server: %v", err)
+// >>>>>>> Conflict 1 of 2 ends
+// 		return nil, err
+// 	}
+//
+// <<<<<<< Conflict 2 of 2
+// %%%%%%% Changes from base #1 to side #1
+//  	resp, err := tangled.RepoHiddenRef(
+//  		r.Context(),
+//  		client,
+//  		&tangled.RepoHiddenRef_Input{
+// -			ForkRef:   f.Ref,
+// -			RemoteRef: f.Ref,
+// +			ForkRef:   currentRef,
+// +			RemoteRef: currentRef,
+//  			Repo:      f.RepoAt().String(),
+//  		},
+//  	)
+//  	if err != nil || !resp.Success {
+//  		if err != nil {
+//  			log.Printf("failed to update tracking branch: %s", err)
+//  		} else {
+//  			log.Printf("failed to update tracking branch: success=false")
+//  		}
+//  		return nil, fmt.Errorf("failed to update tracking branch")
+//  	}
+//
+// -	hiddenRef := fmt.Sprintf("hidden/%s/%s", f.Ref, f.Ref)
+// +	hiddenRef := fmt.Sprintf("hidden/%s/%s", currentRef, currentRef)
+//
+// %%%%%%% Changes from base #2 to side #2
+// -	hiddenRef := fmt.Sprintf("hidden/%s/%s", currentRef, currentRef)
+// +	hiddenRef := fmt.Sprintf("hidden/%s/%s", f.Ref, f.Ref)
+//
+// +++++++ Contents of side #3
+// 	resp, err := tangled.RepoHiddenRef(
+// 		r.Context(),
+// 		client,
+// 		&tangled.RepoHiddenRef_Input{
+// 			ForkRef:   currentRef,
+// 			RemoteRef: currentRef,
+// 			Repo:      f.RepoAt().String(),
+// 		},
+// 	)
+// 	if err != nil || !resp.Success {
+// 		if err != nil {
+// 			log.Printf("failed to update tracking branch: %s", err)
+// 		} else {
+// 			log.Printf("failed to update tracking branch: success=false")
+// 		}
+// 		return nil, fmt.Errorf("failed to update tracking branch")
+// 	}
+//
+// 	hiddenRef := fmt.Sprintf("hidden/%s/%s", currentRef, currentRef)
+// >>>>>>> Conflict 2 of 2 ends
+// 	var status types.AncestorCheckResponse
+// 	forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt()), repoInfo.Name, currentRef, hiddenRef)
+// 	if err != nil {
+// 		log.Printf("failed to check if fork is ahead/behind: %s", err)
+// 		return nil, err
+// 	}
+//
+// 	if err := json.NewDecoder(forkSyncableResp.Body).Decode(&status); err != nil {
+// 		log.Printf("failed to decode fork status: %s", err)
+// 		return nil, err
+// 	}
+//
+// 	forkInfo.Status = status.Status
+// 	return &forkInfo, nil
+// }