commit a597918fbe5cd06d24225c6fadd20c589bc7622e · kot.pink/core

knotserver/handler.go

···

       129
       129
        
       		r.Route("/fork", func(r chi.Router) {

     

       130
       130
        
       			r.Post("/", h.RepoFork)

     

       131
       131
        
       			r.Post("/sync/{branch}", h.RepoForkSync)

     

       132
       132
       +
       			r.Get("/sync/{branch}", h.RepoForkSyncable)

     

       132
       133
        
       		})

     

       133
       134
        
       	})

     

       134
       135

+69 -1

knotserver/routes.go

···

       631
       631
        
       	w.WriteHeader(http.StatusNoContent)

     

       632
       632
        
       }

     

       633
       633
        
       

     

       634
       634
       +
       func (h *Handle) RepoForkSyncable(w http.ResponseWriter, r *http.Request) {

     

       635
       635
       +
       	l := h.l.With("handler", "RepoForkSync")

     

       636
       636
       +
       

     

       637
       637
       +
       	data := struct {

     

       638
       638
       +
       		Did       string `json:"did"`

     

       639
       639
       +
       		Source    string `json:"source"`

     

       640
       640
       +
       		Name      string `json:"name,omitempty"`

     

       641
       641
       +
       		HiddenRef string `json:"hiddenref"`

     

       642
       642
       +
       	}{}

     

       643
       643
       +
       

     

       644
       644
       +
       	if err := json.NewDecoder(r.Body).Decode(&data); err != nil {

     

       645
       645
       +
       		writeError(w, "invalid request body", http.StatusBadRequest)

     

       646
       646
       +
       		return

     

       647
       647
       +
       	}

     

       648
       648
       +
       

     

       649
       649
       +
       	did := data.Did

     

       650
       650
       +
       	source := data.Source

     

       651
       651
       +
       

     

       652
       652
       +
       	if did == "" || source == "" {

     

       653
       653
       +
       		l.Error("invalid request body, empty did or name")

     

       654
       654
       +
       		w.WriteHeader(http.StatusBadRequest)

     

       655
       655
       +
       		return

     

       656
       656
       +
       	}

     

       657
       657
       +
       

     

       658
       658
       +
       	var name string

     

       659
       659
       +
       	if data.Name != "" {

     

       660
       660
       +
       		name = data.Name

     

       661
       661
       +
       	} else {

     

       662
       662
       +
       		name = filepath.Base(source)

     

       663
       663
       +
       	}

     

       664
       664
       +
       

     

       665
       665
       +
       	branch := chi.URLParam(r, "branch")

     

       666
       666
       +
       	branch, _ = url.PathUnescape(branch)

     

       667
       667
       +
       

     

       668
       668
       +
       	relativeRepoPath := filepath.Join(did, name)

     

       669
       669
       +
       	repoPath, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, relativeRepoPath)

     

       670
       670
       +
       

     

       671
       671
       +
       	gr, err := git.PlainOpen(repoPath)

     

       672
       672
       +
       	if err != nil {

     

       673
       673
       +
       		log.Println(err)

     

       674
       674
       +
       		notFound(w)

     

       675
       675
       +
       		return

     

       676
       676
       +
       	}

     

       677
       677
       +
       

     

       678
       678
       +
       	forkCommit, err := gr.ResolveRevision(branch)

     

       679
       679
       +
       	if err != nil {

     

       680
       680
       +
       		l.Error("error resolving ref revision", "msg", err.Error())

     

       681
       681
       +
       		writeError(w, fmt.Sprintf("error resolving revision %s", branch), http.StatusBadRequest)

     

       682
       682
       +
       		return

     

       683
       683
       +
       	}

     

       684
       684
       +
       

     

       685
       685
       +
       	sourceCommit, err := gr.ResolveRevision(data.HiddenRef)

     

       686
       686
       +
       	if err != nil {

     

       687
       687
       +
       		l.Error("error resolving hidden ref revision", "msg", err.Error())

     

       688
       688
       +
       		writeError(w, fmt.Sprintf("error resolving revision %s", data.HiddenRef), http.StatusBadRequest)

     

       689
       689
       +
       		return

     

       690
       690
       +
       	}

     

       691
       691
       +
       

     

       692
       692
       +
       	isAncestor, err := forkCommit.IsAncestor(sourceCommit)

     

       693
       693
       +
       	if err != nil {

     

       694
       694
       +
       		log.Printf("error resolving whether %s is ancestor of %s: %s", branch, data.HiddenRef, err)

     

       695
       695
       +
       		return

     

       696
       696
       +
       	}

     

       697
       697
       +
       

     

       698
       698
       +
       	w.Header().Set("Content-Type", "application/json")

     

       699
       699
       +
       	json.NewEncoder(w).Encode(types.AncestorCheckResponse{IsAncestor: isAncestor})

     

       700
       700
       +
       }

     

       701
       701
       +
       

     

       634
       702
        
       func (h *Handle) RepoForkSync(w http.ResponseWriter, r *http.Request) {

     

       635
       703
        
       	l := h.l.With("handler", "RepoForkSync")

     

       636
       704
        
       

     
···

       676
       744
        
       

     

       677
       745
        
       	err = gr.Sync(branch)

     

       678
       746
        
       	if err != nil {

     

       679
       679
       -
       		l.Error("syncing repo fork", "error", err.Error())

     

       747
       747
       +
       		l.Error("error syncing repo fork", "error", err.Error())

     

       680
       748
        
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       681
       749
        
       		return

     

       682
       750
        
       	}