commit a45996984c720069b8a1bce1d9a96c38fe0d7432 · notnite.com/core

appview/pages/pages.go

···

       478
       478
        
       	RepoInfo      RepoInfo

     

       479
       479
        
       	Collaborators []Collaborator

     

       480
       480
        
       	Active        string

     

       481
       481
       +
       	Branches      []string

     

       482
       482
       +
       	DefaultBranch string

     

       481
       483
        
       	// TODO: use repoinfo.roles

     

       482
       484
        
       	IsCollaboratorInviteAllowed bool

     

       483
       485
        
       }

+18

appview/pages/templates/repo/settings.html

···

       28
       28
        
                   <button class="btn my-2 dark:text-white dark:hover:bg-gray-700" type="text">add collaborator</button>

     

       29
       29
        
               </form>

     

       30
       30
        
           {{ end }}

     

       31
       31
       +
       

     

       32
       32
       +
           <form hx-put="/{{ $.RepoInfo.FullName }}/settings/branches/default" class="mt-6">

     

       33
       33
       +
               <label for="branch">default branch:</label>

     

       34
       34
       +
               <select id="branch" name="branch" required class="p-1 border border-gray-200 bg-white">

     

       35
       35
       +
                   {{ range .Branches }}

     

       36
       36
       +
                       <option

     

       37
       37
       +
                           value="{{ . }}"

     

       38
       38
       +
                           class="py-1"

     

       39
       39
       +
                           {{ if eq . $.DefaultBranch }}

     

       40
       40
       +
                               selected

     

       41
       41
       +
                           {{ end }}

     

       42
       42
       +
                       >

     

       43
       43
       +
                           {{ . }}

     

       44
       44
       +
                       </option>

     

       45
       45
       +
                   {{ end }}

     

       46
       46
       +
               </select>

     

       47
       47
       +
               <button class="btn my-2" type="text">save</button>

     

       48
       48
       +
           </form>

     

       31
       49
        
       {{ end }}

+90

appview/state/repo.go

···

       594
       594
        
       

     

       595
       595
        
       }

     

       596
       596
        
       

     

       597
       597
       +
       func (s *State) SetDefaultBranch(w http.ResponseWriter, r *http.Request) {

     

       598
       598
       +
       	f, err := fullyResolvedRepo(r)

     

       599
       599
       +
       	if err != nil {

     

       600
       600
       +
       		log.Println("failed to get repo and knot", err)

     

       601
       601
       +
       		return

     

       602
       602
       +
       	}

     

       603
       603
       +
       

     

       604
       604
       +
       	branch := r.FormValue("branch")

     

       605
       605
       +
       	if branch == "" {

     

       606
       606
       +
       		http.Error(w, "malformed form", http.StatusBadRequest)

     

       607
       607
       +
       		return

     

       608
       608
       +
       	}

     

       609
       609
       +
       

     

       610
       610
       +
       	secret, err := db.GetRegistrationKey(s.db, f.Knot)

     

       611
       611
       +
       	if err != nil {

     

       612
       612
       +
       		log.Printf("no key found for domain %s: %s\n", f.Knot, err)

     

       613
       613
       +
       		return

     

       614
       614
       +
       	}

     

       615
       615
       +
       

     

       616
       616
       +
       	ksClient, err := NewSignedClient(f.Knot, secret, s.config.Dev)

     

       617
       617
       +
       	if err != nil {

     

       618
       618
       +
       		log.Println("failed to create client to ", f.Knot)

     

       619
       619
       +
       		return

     

       620
       620
       +
       	}

     

       621
       621
       +
       

     

       622
       622
       +
       	ksResp, err := ksClient.SetDefaultBranch(f.OwnerDid(), f.RepoName, branch)

     

       623
       623
       +
       	if err != nil {

     

       624
       624
       +
       		log.Printf("failed to make request to %s: %s", f.Knot, err)

     

       625
       625
       +
       		return

     

       626
       626
       +
       	}

     

       627
       627
       +
       

     

       628
       628
       +
       	if ksResp.StatusCode != http.StatusNoContent {

     

       629
       629
       +
       		s.pages.Notice(w, "repo-settings", "Failed to set default branch. Try again later.")

     

       630
       630
       +
       		return

     

       631
       631
       +
       	}

     

       632
       632
       +
       

     

       633
       633
       +
       	w.Write([]byte(fmt.Sprint("default branch set to: ", branch)))

     

       634
       634
       +
       }

     

       635
       635
       +
       

     

       597
       636
        
       func (s *State) RepoSettings(w http.ResponseWriter, r *http.Request) {

     

       598
       637
        
       	f, err := fullyResolvedRepo(r)

     

       599
       638
        
       	if err != nil {

     
···

       618
       657
        
       			}

     

       619
       658
        
       		}

     

       620
       659
        
       

     

       660
       660
       +
       		var branchNames []string

     

       661
       661
       +
       		var defaultBranch string

     

       662
       662
       +
       		us, err := NewUnsignedClient(f.Knot, s.config.Dev)

     

       663
       663
       +
       		if err != nil {

     

       664
       664
       +
       			log.Println("failed to create unsigned client", err)

     

       665
       665
       +
       		} else {

     

       666
       666
       +
       			resp, err := us.Branches(f.OwnerDid(), f.RepoName)

     

       667
       667
       +
       			if err != nil {

     

       668
       668
       +
       				log.Println("failed to reach knotserver", err)

     

       669
       669
       +
       			} else {

     

       670
       670
       +
       				defer resp.Body.Close()

     

       671
       671
       +
       

     

       672
       672
       +
       				body, err := io.ReadAll(resp.Body)

     

       673
       673
       +
       				if err != nil {

     

       674
       674
       +
       					log.Printf("Error reading response body: %v", err)

     

       675
       675
       +
       				} else {

     

       676
       676
       +
       					var result types.RepoBranchesResponse

     

       677
       677
       +
       					err = json.Unmarshal(body, &result)

     

       678
       678
       +
       					if err != nil {

     

       679
       679
       +
       						log.Println("failed to parse response:", err)

     

       680
       680
       +
       					} else {

     

       681
       681
       +
       						for _, branch := range result.Branches {

     

       682
       682
       +
       							branchNames = append(branchNames, branch.Name)

     

       683
       683
       +
       						}

     

       684
       684
       +
       					}

     

       685
       685
       +
       				}

     

       686
       686
       +
       			}

     

       687
       687
       +
       

     

       688
       688
       +
       			resp, err = us.DefaultBranch(f.OwnerDid(), f.RepoName)

     

       689
       689
       +
       			if err != nil {

     

       690
       690
       +
       				log.Println("failed to reach knotserver", err)

     

       691
       691
       +
       			} else {

     

       692
       692
       +
       				defer resp.Body.Close()

     

       693
       693
       +
       

     

       694
       694
       +
       				body, err := io.ReadAll(resp.Body)

     

       695
       695
       +
       				if err != nil {

     

       696
       696
       +
       					log.Printf("Error reading response body: %v", err)

     

       697
       697
       +
       				} else {

     

       698
       698
       +
       					var result types.RepoDefaultBranchResponse

     

       699
       699
       +
       					err = json.Unmarshal(body, &result)

     

       700
       700
       +
       					if err != nil {

     

       701
       701
       +
       						log.Println("failed to parse response:", err)

     

       702
       702
       +
       					} else {

     

       703
       703
       +
       						defaultBranch = result.Branch

     

       704
       704
       +
       					}

     

       705
       705
       +
       				}

     

       706
       706
       +
       			}

     

       707
       707
       +
       		}

     

       708
       708
       +
       

     

       621
       709
        
       		s.pages.RepoSettings(w, pages.RepoSettingsParams{

     

       622
       710
        
       			LoggedInUser:                user,

     

       623
       711
        
       			RepoInfo:                    f.RepoInfo(s, user),

     

       624
       712
        
       			Collaborators:               repoCollaborators,

     

       625
       713
        
       			IsCollaboratorInviteAllowed: isCollaboratorInviteAllowed,

     

       714
       714
       +
       			Branches:                    branchNames,

     

       715
       715
       +
       			DefaultBranch:               defaultBranch,

     

       626
       716
        
       		})

     

       627
       717
        
       	}

     

       628
       718
        
       }

appview/state/router.go

···

       143
       143
        
       				r.With(RepoPermissionMiddleware(s, "repo:settings")).Route("/settings", func(r chi.Router) {

     

       144
       144
        
       					r.Get("/", s.RepoSettings)

     

       145
       145
        
       					r.With(RepoPermissionMiddleware(s, "repo:invite")).Put("/collaborator", s.AddCollaborator)

     

       146
       146
       +
       					r.Put("/branches/default", s.SetDefaultBranch)

     

       146
       147
        
       				})

     

       147
       148
        
       			})

     

       148
       149
        
       		})

+33

appview/state/signer.go

···

       140
       140
        
       	return s.client.Do(req)

     

       141
       141
        
       }

     

       142
       142
        
       

     

       143
       143
       +
       func (s *SignedClient) SetDefaultBranch(ownerDid, repoName, branch string) (*http.Response, error) {

     

       144
       144
       +
       	const (

     

       145
       145
       +
       		Method = "PUT"

     

       146
       146
       +
       	)

     

       147
       147
       +
       	endpoint := fmt.Sprintf("/%s/%s/branches/default", ownerDid, repoName)

     

       148
       148
       +
       

     

       149
       149
       +
       	body, _ := json.Marshal(map[string]any{

     

       150
       150
       +
       		"branch": branch,

     

       151
       151
       +
       	})

     

       152
       152
       +
       

     

       153
       153
       +
       	req, err := s.newRequest(Method, endpoint, body)

     

       154
       154
       +
       	if err != nil {

     

       155
       155
       +
       		return nil, err

     

       156
       156
       +
       	}

     

       157
       157
       +
       

     

       158
       158
       +
       	return s.client.Do(req)

     

       159
       159
       +
       }

     

       160
       160
       +
       

     

       143
       161
        
       func (s *SignedClient) AddCollaborator(ownerDid, repoName, memberDid string) (*http.Response, error) {

     

       144
       162
        
       	const (

     

       145
       163
        
       		Method = "POST"

     
···

       268
       286
        
       

     

       269
       287
        
       	return us.client.Do(req)

     

       270
       288
        
       }

     

       289
       289
       +
       

     

       290
       290
       +
       func (us *UnsignedClient) DefaultBranch(ownerDid, repoName string) (*http.Response, error) {

     

       291
       291
       +
       	const (

     

       292
       292
       +
       		Method = "GET"

     

       293
       293
       +
       	)

     

       294
       294
       +
       

     

       295
       295
       +
       	endpoint := fmt.Sprintf("/%s/%s/branches/default", ownerDid, repoName)

     

       296
       296
       +
       

     

       297
       297
       +
       	req, err := us.newRequest(Method, endpoint, nil)

     

       298
       298
       +
       	if err != nil {

     

       299
       299
       +
       		return nil, err

     

       300
       300
       +
       	}

     

       301
       301
       +
       

     

       302
       302
       +
       	return us.client.Do(req)

     

       303
       303
       +
       }

knotserver/git/git.go

···

       228
       228
        
       	return branches, nil

     

       229
       229
        
       }

     

       230
       230
        
       

     

       231
       231
       +
       func (g *GitRepo) SetDefaultBranch(branch string) error {

     

       232
       232
       +
       	ref := plumbing.NewSymbolicReference(plumbing.HEAD, plumbing.NewBranchReferenceName(branch))

     

       233
       233
       +
       	return g.r.Storer.SetReference(ref)

     

       234
       234
       +
       }

     

       235
       235
       +
       

     

       231
       236
        
       func (g *GitRepo) FindMainBranch() (string, error) {

     

       232
       237
        
       	ref, err := g.r.Head()

     

       233
       238
        
       	if err != nil {

+7 -1

knotserver/handler.go

···

       102
       102
        
       			r.Get("/archive/{file}", h.Archive)

     

       103
       103
        
       			r.Get("/commit/{ref}", h.Diff)

     

       104
       104
        
       			r.Get("/tags", h.Tags)

     

       105
       105
       -
       			r.Get("/branches", h.Branches)

     

       105
       105
       +
       			r.Route("/branches", func(r chi.Router) {

     

       106
       106
       +
       				r.Get("/", h.Branches)

     

       107
       107
       +
       				r.Route("/default", func(r chi.Router) {

     

       108
       108
       +
       					r.Get("/", h.DefaultBranch)

     

       109
       109
       +
       					r.With(h.VerifySignature).Put("/", h.SetDefaultBranch)

     

       110
       110
       +
       				})

     

       111
       111
       +
       			})

     

       106
       112
        
       		})

     

       107
       113
        
       	})

     

       108
       114

+51

knotserver/routes.go

···

       739
       739
        
       	w.WriteHeader(http.StatusNoContent)

     

       740
       740
        
       }

     

       741
       741
        
       

     

       742
       742
       +
       func (h *Handle) DefaultBranch(w http.ResponseWriter, r *http.Request) {

     

       743
       743
       +
       	l := h.l.With("handler", "DefaultBranch")

     

       744
       744
       +
       	path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r))

     

       745
       745
       +
       

     

       746
       746
       +
       	gr, err := git.Open(path, "")

     

       747
       747
       +
       	if err != nil {

     

       748
       748
       +
       		notFound(w)

     

       749
       749
       +
       		return

     

       750
       750
       +
       	}

     

       751
       751
       +
       

     

       752
       752
       +
       	branch, err := gr.FindMainBranch()

     

       753
       753
       +
       	if err != nil {

     

       754
       754
       +
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       755
       755
       +
       		l.Error("getting default branch", "error", err.Error())

     

       756
       756
       +
       		return

     

       757
       757
       +
       	}

     

       758
       758
       +
       

     

       759
       759
       +
       	writeJSON(w, types.RepoDefaultBranchResponse{

     

       760
       760
       +
       		Branch: branch,

     

       761
       761
       +
       	})

     

       762
       762
       +
       }

     

       763
       763
       +
       

     

       764
       764
       +
       func (h *Handle) SetDefaultBranch(w http.ResponseWriter, r *http.Request) {

     

       765
       765
       +
       	l := h.l.With("handler", "SetDefaultBranch")

     

       766
       766
       +
       	path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r))

     

       767
       767
       +
       

     

       768
       768
       +
       	data := struct {

     

       769
       769
       +
       		Branch string `json:"branch"`

     

       770
       770
       +
       	}{}

     

       771
       771
       +
       

     

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

     

       773
       773
       +
       		writeError(w, err.Error(), http.StatusBadRequest)

     

       774
       774
       +
       		return

     

       775
       775
       +
       	}

     

       776
       776
       +
       

     

       777
       777
       +
       	gr, err := git.Open(path, "")

     

       778
       778
       +
       	if err != nil {

     

       779
       779
       +
       		notFound(w)

     

       780
       780
       +
       		return

     

       781
       781
       +
       	}

     

       782
       782
       +
       

     

       783
       783
       +
       	err = gr.SetDefaultBranch(data.Branch)

     

       784
       784
       +
       	if err != nil {

     

       785
       785
       +
       		writeError(w, err.Error(), http.StatusInternalServerError)

     

       786
       786
       +
       		l.Error("setting default branch", "error", err.Error())

     

       787
       787
       +
       		return

     

       788
       788
       +
       	}

     

       789
       789
       +
       

     

       790
       790
       +
       	w.WriteHeader(http.StatusNoContent)

     

       791
       791
       +
       }

     

       792
       792
       +
       

     

       742
       793
        
       func (h *Handle) Init(w http.ResponseWriter, r *http.Request) {

     

       743
       794
        
       	l := h.l.With("handler", "Init")

     

       744
       795

types/repo.go

···

       63
       63
        
       	Branches []Branch `json:"branches,omitempty"`

     

       64
       64
        
       }

     

       65
       65
        
       

     

       66
       66
       +
       type RepoDefaultBranchResponse struct {

     

       67
       67
       +
       	Branch string `json:"branch,omitempty"`

     

       68
       68
       +
       }

     

       69
       69
       +
       

     

       66
       70
        
       type RepoBlobResponse struct {

     

       67
       71
        
       	Contents string `json:"contents,omitempty"`

     

       68
       72
        
       	Ref      string `json:"ref,omitempty"`