+2 -2

knotserver/events.go

··· 15 15 WriteBufferSize: 1024, 16 16 } 17 17 18 18 - func (h *Handle) Events(w http.ResponseWriter, r *http.Request) { 18 18 + func (h *Knot) Events(w http.ResponseWriter, r *http.Request) { 19 19 l := h.l.With("handler", "OpLog") 20 20 l.Debug("received new connection") 21 21 ··· 83 83 } 84 84 } 85 85 86 86 - func (h *Handle) streamOps(conn *websocket.Conn, cursor *int64) error { 86 86 + func (h *Knot) streamOps(conn *websocket.Conn, cursor *int64) error { 87 87 events, err := h.db.GetEvents(*cursor) 88 88 if err != nil { 89 89 h.l.Error("failed to fetch events from db", "err", err, "cursor", cursor)

-48

knotserver/file.go

··· 1 1 - package knotserver 2 2 - 3 3 - import ( 4 4 - "bytes" 5 5 - "io" 6 6 - "log/slog" 7 7 - "net/http" 8 8 - "strings" 9 9 - 10 10 - "tangled.sh/tangled.sh/core/types" 11 11 - ) 12 12 - 13 13 - func countLines(r io.Reader) (int, error) { 14 14 - buf := make([]byte, 32*1024) 15 15 - bufLen := 0 16 16 - count := 0 17 17 - nl := []byte{'\n'} 18 18 - 19 19 - for { 20 20 - c, err := r.Read(buf) 21 21 - if c > 0 { 22 22 - bufLen += c 23 23 - } 24 24 - count += bytes.Count(buf[:c], nl) 25 25 - 26 26 - switch { 27 27 - case err == io.EOF: 28 28 - /* handle last line not having a newline at the end */ 29 29 - if bufLen >= 1 && buf[(bufLen-1)%(32*1024)] != '\n' { 30 30 - count++ 31 31 - } 32 32 - return count, nil 33 33 - case err != nil: 34 34 - return 0, err 35 35 - } 36 36 - } 37 37 - } 38 38 - 39 39 - func (h *Handle) showFile(resp types.RepoBlobResponse, w http.ResponseWriter, l *slog.Logger) { 40 40 - lc, err := countLines(strings.NewReader(resp.Contents)) 41 41 - if err != nil { 42 42 - // Non-fatal, we'll just skip showing line numbers in the template. 43 43 - l.Warn("counting lines", "error", err) 44 44 - } 45 45 - 46 46 - resp.Lines = lc 47 47 - writeJSON(w, resp) 48 48 - }

+4 -4

knotserver/git.go

··· 13 13 "tangled.sh/tangled.sh/core/knotserver/git/service" 14 14 ) 15 15 16 16 - func (d *Handle) InfoRefs(w http.ResponseWriter, r *http.Request) { 16 16 + func (d *Knot) InfoRefs(w http.ResponseWriter, r *http.Request) { 17 17 did := chi.URLParam(r, "did") 18 18 name := chi.URLParam(r, "name") 19 19 repoName, err := securejoin.SecureJoin(did, name) ··· 56 56 } 57 57 } 58 58 59 59 - func (d *Handle) UploadPack(w http.ResponseWriter, r *http.Request) { 59 59 + func (d *Knot) UploadPack(w http.ResponseWriter, r *http.Request) { 60 60 did := chi.URLParam(r, "did") 61 61 name := chi.URLParam(r, "name") 62 62 repo, err := securejoin.SecureJoin(d.c.Repo.ScanPath, filepath.Join(did, name)) ··· 105 105 } 106 106 } 107 107 108 108 - func (d *Handle) ReceivePack(w http.ResponseWriter, r *http.Request) { 108 108 + func (d *Knot) ReceivePack(w http.ResponseWriter, r *http.Request) { 109 109 did := chi.URLParam(r, "did") 110 110 name := chi.URLParam(r, "name") 111 111 _, err := securejoin.SecureJoin(d.c.Repo.ScanPath, filepath.Join(did, name)) ··· 118 118 d.RejectPush(w, r, name) 119 119 } 120 120 121 121 - func (d *Handle) RejectPush(w http.ResponseWriter, r *http.Request, unqualifiedRepoName string) { 121 121 + func (d *Knot) RejectPush(w http.ResponseWriter, r *http.Request, unqualifiedRepoName string) { 122 122 // A text/plain response will cause git to print each line of the body 123 123 // prefixed with "remote: ". 124 124 w.Header().Set("content-type", "text/plain; charset=UTF-8")

-1069

knotserver/handler.go

··· 1 1 - package knotserver 2 2 - 3 3 - import ( 4 4 - "compress/gzip" 5 5 - "context" 6 6 - "crypto/sha256" 7 7 - "encoding/json" 8 8 - "errors" 9 9 - "fmt" 10 10 - "log" 11 11 - "net/http" 12 12 - "net/url" 13 13 - "path/filepath" 14 14 - "strconv" 15 15 - "strings" 16 16 - "sync" 17 17 - "time" 18 18 - 19 19 - securejoin "github.com/cyphar/filepath-securejoin" 20 20 - "github.com/gliderlabs/ssh" 21 21 - "github.com/go-chi/chi/v5" 22 22 - "github.com/go-git/go-git/v5/plumbing" 23 23 - "github.com/go-git/go-git/v5/plumbing/object" 24 24 - "tangled.sh/tangled.sh/core/knotserver/db" 25 25 - "tangled.sh/tangled.sh/core/knotserver/git" 26 26 - "tangled.sh/tangled.sh/core/types" 27 27 - ) 28 28 - 29 29 - func (h *Handle) Index(w http.ResponseWriter, r *http.Request) { 30 30 - w.Write([]byte("This is a knot server. More info at https://tangled.sh")) 31 31 - } 32 32 - 33 33 - func (h *Handle) Capabilities(w http.ResponseWriter, r *http.Request) { 34 34 - w.Header().Set("Content-Type", "application/json") 35 35 - 36 36 - capabilities := map[string]any{ 37 37 - "pull_requests": map[string]any{ 38 38 - "format_patch": true, 39 39 - "patch_submissions": true, 40 40 - "branch_submissions": true, 41 41 - "fork_submissions": true, 42 42 - }, 43 43 - "xrpc": true, 44 44 - } 45 45 - 46 46 - jsonData, err := json.Marshal(capabilities) 47 47 - if err != nil { 48 48 - http.Error(w, "Failed to serialize JSON", http.StatusInternalServerError) 49 49 - return 50 50 - } 51 51 - 52 52 - w.Write(jsonData) 53 53 - } 54 54 - 55 55 - func (h *Handle) RepoIndex(w http.ResponseWriter, r *http.Request) { 56 56 - path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 57 57 - l := h.l.With("path", path, "handler", "RepoIndex") 58 58 - ref := chi.URLParam(r, "ref") 59 59 - ref, _ = url.PathUnescape(ref) 60 60 - 61 61 - gr, err := git.Open(path, ref) 62 62 - if err != nil { 63 63 - plain, err2 := git.PlainOpen(path) 64 64 - if err2 != nil { 65 65 - l.Error("opening repo", "error", err2.Error()) 66 66 - notFound(w) 67 67 - return 68 68 - } 69 69 - branches, _ := plain.Branches() 70 70 - 71 71 - log.Println(err) 72 72 - 73 73 - if errors.Is(err, plumbing.ErrReferenceNotFound) { 74 74 - resp := types.RepoIndexResponse{ 75 75 - IsEmpty: true, 76 76 - Branches: branches, 77 77 - } 78 78 - writeJSON(w, resp) 79 79 - return 80 80 - } else { 81 81 - l.Error("opening repo", "error", err.Error()) 82 82 - notFound(w) 83 83 - return 84 84 - } 85 85 - } 86 86 - 87 87 - var ( 88 88 - commits []*object.Commit 89 89 - total int 90 90 - branches []types.Branch 91 91 - files []types.NiceTree 92 92 - tags []object.Tag 93 93 - ) 94 94 - 95 95 - var wg sync.WaitGroup 96 96 - errorsCh := make(chan error, 5) 97 97 - 98 98 - wg.Add(1) 99 99 - go func() { 100 100 - defer wg.Done() 101 101 - cs, err := gr.Commits(0, 60) 102 102 - if err != nil { 103 103 - errorsCh <- fmt.Errorf("commits: %w", err) 104 104 - return 105 105 - } 106 106 - commits = cs 107 107 - }() 108 108 - 109 109 - wg.Add(1) 110 110 - go func() { 111 111 - defer wg.Done() 112 112 - t, err := gr.TotalCommits() 113 113 - if err != nil { 114 114 - errorsCh <- fmt.Errorf("calculating total: %w", err) 115 115 - return 116 116 - } 117 117 - total = t 118 118 - }() 119 119 - 120 120 - wg.Add(1) 121 121 - go func() { 122 122 - defer wg.Done() 123 123 - bs, err := gr.Branches() 124 124 - if err != nil { 125 125 - errorsCh <- fmt.Errorf("fetching branches: %w", err) 126 126 - return 127 127 - } 128 128 - branches = bs 129 129 - }() 130 130 - 131 131 - wg.Add(1) 132 132 - go func() { 133 133 - defer wg.Done() 134 134 - ts, err := gr.Tags() 135 135 - if err != nil { 136 136 - errorsCh <- fmt.Errorf("fetching tags: %w", err) 137 137 - return 138 138 - } 139 139 - tags = ts 140 140 - }() 141 141 - 142 142 - wg.Add(1) 143 143 - go func() { 144 144 - defer wg.Done() 145 145 - fs, err := gr.FileTree(r.Context(), "") 146 146 - if err != nil { 147 147 - errorsCh <- fmt.Errorf("fetching filetree: %w", err) 148 148 - return 149 149 - } 150 150 - files = fs 151 151 - }() 152 152 - 153 153 - wg.Wait() 154 154 - close(errorsCh) 155 155 - 156 156 - // show any errors 157 157 - for err := range errorsCh { 158 158 - l.Error("loading repo", "error", err.Error()) 159 159 - writeError(w, err.Error(), http.StatusInternalServerError) 160 160 - return 161 161 - } 162 162 - 163 163 - rtags := []*types.TagReference{} 164 164 - for _, tag := range tags { 165 165 - var target *object.Tag 166 166 - if tag.Target != plumbing.ZeroHash { 167 167 - target = &tag 168 168 - } 169 169 - tr := types.TagReference{ 170 170 - Tag: target, 171 171 - } 172 172 - 173 173 - tr.Reference = types.Reference{ 174 174 - Name: tag.Name, 175 175 - Hash: tag.Hash.String(), 176 176 - } 177 177 - 178 178 - if tag.Message != "" { 179 179 - tr.Message = tag.Message 180 180 - } 181 181 - 182 182 - rtags = append(rtags, &tr) 183 183 - } 184 184 - 185 185 - var readmeContent string 186 186 - var readmeFile string 187 187 - for _, readme := range h.c.Repo.Readme { 188 188 - content, _ := gr.FileContent(readme) 189 189 - if len(content) > 0 { 190 190 - readmeContent = string(content) 191 191 - readmeFile = readme 192 192 - } 193 193 - } 194 194 - 195 195 - if ref == "" { 196 196 - mainBranch, err := gr.FindMainBranch() 197 197 - if err != nil { 198 198 - writeError(w, err.Error(), http.StatusInternalServerError) 199 199 - l.Error("finding main branch", "error", err.Error()) 200 200 - return 201 201 - } 202 202 - ref = mainBranch 203 203 - } 204 204 - 205 205 - resp := types.RepoIndexResponse{ 206 206 - IsEmpty: false, 207 207 - Ref: ref, 208 208 - Commits: commits, 209 209 - Description: getDescription(path), 210 210 - Readme: readmeContent, 211 211 - ReadmeFileName: readmeFile, 212 212 - Files: files, 213 213 - Branches: branches, 214 214 - Tags: rtags, 215 215 - TotalCommits: total, 216 216 - } 217 217 - 218 218 - writeJSON(w, resp) 219 219 - } 220 220 - 221 221 - func (h *Handle) RepoTree(w http.ResponseWriter, r *http.Request) { 222 222 - treePath := chi.URLParam(r, "*") 223 223 - ref := chi.URLParam(r, "ref") 224 224 - ref, _ = url.PathUnescape(ref) 225 225 - 226 226 - l := h.l.With("handler", "RepoTree", "ref", ref, "treePath", treePath) 227 227 - 228 228 - path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 229 229 - gr, err := git.Open(path, ref) 230 230 - if err != nil { 231 231 - notFound(w) 232 232 - return 233 233 - } 234 234 - 235 235 - files, err := gr.FileTree(r.Context(), treePath) 236 236 - if err != nil { 237 237 - writeError(w, err.Error(), http.StatusInternalServerError) 238 238 - l.Error("file tree", "error", err.Error()) 239 239 - return 240 240 - } 241 241 - 242 242 - resp := types.RepoTreeResponse{ 243 243 - Ref: ref, 244 244 - Parent: treePath, 245 245 - Description: getDescription(path), 246 246 - DotDot: filepath.Dir(treePath), 247 247 - Files: files, 248 248 - } 249 249 - 250 250 - writeJSON(w, resp) 251 251 - } 252 252 - 253 253 - func (h *Handle) BlobRaw(w http.ResponseWriter, r *http.Request) { 254 254 - treePath := chi.URLParam(r, "*") 255 255 - ref := chi.URLParam(r, "ref") 256 256 - ref, _ = url.PathUnescape(ref) 257 257 - 258 258 - l := h.l.With("handler", "BlobRaw", "ref", ref, "treePath", treePath) 259 259 - 260 260 - path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 261 261 - gr, err := git.Open(path, ref) 262 262 - if err != nil { 263 263 - notFound(w) 264 264 - return 265 265 - } 266 266 - 267 267 - contents, err := gr.RawContent(treePath) 268 268 - if err != nil { 269 269 - writeError(w, err.Error(), http.StatusBadRequest) 270 270 - l.Error("file content", "error", err.Error()) 271 271 - return 272 272 - } 273 273 - 274 274 - mimeType := http.DetectContentType(contents) 275 275 - 276 276 - // exception for svg 277 277 - if filepath.Ext(treePath) == ".svg" { 278 278 - mimeType = "image/svg+xml" 279 279 - } 280 280 - 281 281 - contentHash := sha256.Sum256(contents) 282 282 - eTag := fmt.Sprintf("\"%x\"", contentHash) 283 283 - 284 284 - // allow image, video, and text/plain files to be served directly 285 285 - switch { 286 286 - case strings.HasPrefix(mimeType, "image/"), strings.HasPrefix(mimeType, "video/"): 287 287 - if clientETag := r.Header.Get("If-None-Match"); clientETag == eTag { 288 288 - w.WriteHeader(http.StatusNotModified) 289 289 - return 290 290 - } 291 291 - w.Header().Set("ETag", eTag) 292 292 - 293 293 - case strings.HasPrefix(mimeType, "text/plain"): 294 294 - w.Header().Set("Cache-Control", "public, no-cache") 295 295 - 296 296 - default: 297 297 - l.Error("attempted to serve disallowed file type", "mimetype", mimeType) 298 298 - writeError(w, "only image, video, and text files can be accessed directly", http.StatusForbidden) 299 299 - return 300 300 - } 301 301 - 302 302 - w.Header().Set("Content-Type", mimeType) 303 303 - w.Write(contents) 304 304 - } 305 305 - 306 306 - func (h *Handle) Blob(w http.ResponseWriter, r *http.Request) { 307 307 - treePath := chi.URLParam(r, "*") 308 308 - ref := chi.URLParam(r, "ref") 309 309 - ref, _ = url.PathUnescape(ref) 310 310 - 311 311 - l := h.l.With("handler", "Blob", "ref", ref, "treePath", treePath) 312 312 - 313 313 - path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 314 314 - gr, err := git.Open(path, ref) 315 315 - if err != nil { 316 316 - notFound(w) 317 317 - return 318 318 - } 319 319 - 320 320 - var isBinaryFile bool = false 321 321 - contents, err := gr.FileContent(treePath) 322 322 - if errors.Is(err, git.ErrBinaryFile) { 323 323 - isBinaryFile = true 324 324 - } else if errors.Is(err, object.ErrFileNotFound) { 325 325 - notFound(w) 326 326 - return 327 327 - } else if err != nil { 328 328 - writeError(w, err.Error(), http.StatusInternalServerError) 329 329 - return 330 330 - } 331 331 - 332 332 - bytes := []byte(contents) 333 333 - // safe := string(sanitize(bytes)) 334 334 - sizeHint := len(bytes) 335 335 - 336 336 - resp := types.RepoBlobResponse{ 337 337 - Ref: ref, 338 338 - Contents: string(bytes), 339 339 - Path: treePath, 340 340 - IsBinary: isBinaryFile, 341 341 - SizeHint: uint64(sizeHint), 342 342 - } 343 343 - 344 344 - h.showFile(resp, w, l) 345 345 - } 346 346 - 347 347 - func (h *Handle) Archive(w http.ResponseWriter, r *http.Request) { 348 348 - name := chi.URLParam(r, "name") 349 349 - file := chi.URLParam(r, "file") 350 350 - 351 351 - l := h.l.With("handler", "Archive", "name", name, "file", file) 352 352 - 353 353 - // TODO: extend this to add more files compression (e.g.: xz) 354 354 - if !strings.HasSuffix(file, ".tar.gz") { 355 355 - notFound(w) 356 356 - return 357 357 - } 358 358 - 359 359 - ref := strings.TrimSuffix(file, ".tar.gz") 360 360 - 361 361 - unescapedRef, err := url.PathUnescape(ref) 362 362 - if err != nil { 363 363 - notFound(w) 364 364 - return 365 365 - } 366 366 - 367 367 - safeRefFilename := strings.ReplaceAll(plumbing.ReferenceName(unescapedRef).Short(), "/", "-") 368 368 - 369 369 - // This allows the browser to use a proper name for the file when 370 370 - // downloading 371 371 - filename := fmt.Sprintf("%s-%s.tar.gz", name, safeRefFilename) 372 372 - setContentDisposition(w, filename) 373 373 - setGZipMIME(w) 374 374 - 375 375 - path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 376 376 - gr, err := git.Open(path, unescapedRef) 377 377 - if err != nil { 378 378 - notFound(w) 379 379 - return 380 380 - } 381 381 - 382 382 - gw := gzip.NewWriter(w) 383 383 - defer gw.Close() 384 384 - 385 385 - prefix := fmt.Sprintf("%s-%s", name, safeRefFilename) 386 386 - err = gr.WriteTar(gw, prefix) 387 387 - if err != nil { 388 388 - // once we start writing to the body we can't report error anymore 389 389 - // so we are only left with printing the error. 390 390 - l.Error("writing tar file", "error", err.Error()) 391 391 - return 392 392 - } 393 393 - 394 394 - err = gw.Flush() 395 395 - if err != nil { 396 396 - // once we start writing to the body we can't report error anymore 397 397 - // so we are only left with printing the error. 398 398 - l.Error("flushing?", "error", err.Error()) 399 399 - return 400 400 - } 401 401 - } 402 402 - 403 403 - func (h *Handle) Log(w http.ResponseWriter, r *http.Request) { 404 404 - ref := chi.URLParam(r, "ref") 405 405 - ref, _ = url.PathUnescape(ref) 406 406 - 407 407 - path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 408 408 - 409 409 - l := h.l.With("handler", "Log", "ref", ref, "path", path) 410 410 - 411 411 - gr, err := git.Open(path, ref) 412 412 - if err != nil { 413 413 - notFound(w) 414 414 - return 415 415 - } 416 416 - 417 417 - // Get page parameters 418 418 - page := 1 419 419 - pageSize := 30 420 420 - 421 421 - if pageParam := r.URL.Query().Get("page"); pageParam != "" { 422 422 - if p, err := strconv.Atoi(pageParam); err == nil && p > 0 { 423 423 - page = p 424 424 - } 425 425 - } 426 426 - 427 427 - if pageSizeParam := r.URL.Query().Get("per_page"); pageSizeParam != "" { 428 428 - if ps, err := strconv.Atoi(pageSizeParam); err == nil && ps > 0 { 429 429 - pageSize = ps 430 430 - } 431 431 - } 432 432 - 433 433 - // convert to offset/limit 434 434 - offset := (page - 1) * pageSize 435 435 - limit := pageSize 436 436 - 437 437 - commits, err := gr.Commits(offset, limit) 438 438 - if err != nil { 439 439 - writeError(w, err.Error(), http.StatusInternalServerError) 440 440 - l.Error("fetching commits", "error", err.Error()) 441 441 - return 442 442 - } 443 443 - 444 444 - total := len(commits) 445 445 - 446 446 - resp := types.RepoLogResponse{ 447 447 - Commits: commits, 448 448 - Ref: ref, 449 449 - Description: getDescription(path), 450 450 - Log: true, 451 451 - Total: total, 452 452 - Page: page, 453 453 - PerPage: pageSize, 454 454 - } 455 455 - 456 456 - writeJSON(w, resp) 457 457 - } 458 458 - 459 459 - func (h *Handle) Diff(w http.ResponseWriter, r *http.Request) { 460 460 - ref := chi.URLParam(r, "ref") 461 461 - ref, _ = url.PathUnescape(ref) 462 462 - 463 463 - l := h.l.With("handler", "Diff", "ref", ref) 464 464 - 465 465 - path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 466 466 - gr, err := git.Open(path, ref) 467 467 - if err != nil { 468 468 - notFound(w) 469 469 - return 470 470 - } 471 471 - 472 472 - diff, err := gr.Diff() 473 473 - if err != nil { 474 474 - writeError(w, err.Error(), http.StatusInternalServerError) 475 475 - l.Error("getting diff", "error", err.Error()) 476 476 - return 477 477 - } 478 478 - 479 479 - resp := types.RepoCommitResponse{ 480 480 - Ref: ref, 481 481 - Diff: diff, 482 482 - } 483 483 - 484 484 - writeJSON(w, resp) 485 485 - } 486 486 - 487 487 - func (h *Handle) Tags(w http.ResponseWriter, r *http.Request) { 488 488 - path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 489 489 - l := h.l.With("handler", "Refs") 490 490 - 491 491 - gr, err := git.Open(path, "") 492 492 - if err != nil { 493 493 - notFound(w) 494 494 - return 495 495 - } 496 496 - 497 497 - tags, err := gr.Tags() 498 498 - if err != nil { 499 499 - // Non-fatal, we *should* have at least one branch to show. 500 500 - l.Warn("getting tags", "error", err.Error()) 501 501 - } 502 502 - 503 503 - rtags := []*types.TagReference{} 504 504 - for _, tag := range tags { 505 505 - var target *object.Tag 506 506 - if tag.Target != plumbing.ZeroHash { 507 507 - target = &tag 508 508 - } 509 509 - tr := types.TagReference{ 510 510 - Tag: target, 511 511 - } 512 512 - 513 513 - tr.Reference = types.Reference{ 514 514 - Name: tag.Name, 515 515 - Hash: tag.Hash.String(), 516 516 - } 517 517 - 518 518 - if tag.Message != "" { 519 519 - tr.Message = tag.Message 520 520 - } 521 521 - 522 522 - rtags = append(rtags, &tr) 523 523 - } 524 524 - 525 525 - resp := types.RepoTagsResponse{ 526 526 - Tags: rtags, 527 527 - } 528 528 - 529 529 - writeJSON(w, resp) 530 530 - } 531 531 - 532 532 - func (h *Handle) Branches(w http.ResponseWriter, r *http.Request) { 533 533 - path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 534 534 - 535 535 - gr, err := git.PlainOpen(path) 536 536 - if err != nil { 537 537 - notFound(w) 538 538 - return 539 539 - } 540 540 - 541 541 - branches, _ := gr.Branches() 542 542 - 543 543 - resp := types.RepoBranchesResponse{ 544 544 - Branches: branches, 545 545 - } 546 546 - 547 547 - writeJSON(w, resp) 548 548 - } 549 549 - 550 550 - func (h *Handle) Branch(w http.ResponseWriter, r *http.Request) { 551 551 - path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 552 552 - branchName := chi.URLParam(r, "branch") 553 553 - branchName, _ = url.PathUnescape(branchName) 554 554 - 555 555 - l := h.l.With("handler", "Branch") 556 556 - 557 557 - gr, err := git.PlainOpen(path) 558 558 - if err != nil { 559 559 - notFound(w) 560 560 - return 561 561 - } 562 562 - 563 563 - ref, err := gr.Branch(branchName) 564 564 - if err != nil { 565 565 - l.Error("getting branch", "error", err.Error()) 566 566 - writeError(w, err.Error(), http.StatusInternalServerError) 567 567 - return 568 568 - } 569 569 - 570 570 - commit, err := gr.Commit(ref.Hash()) 571 571 - if err != nil { 572 572 - l.Error("getting commit object", "error", err.Error()) 573 573 - writeError(w, err.Error(), http.StatusInternalServerError) 574 574 - return 575 575 - } 576 576 - 577 577 - defaultBranch, err := gr.FindMainBranch() 578 578 - isDefault := false 579 579 - if err != nil { 580 580 - l.Error("getting default branch", "error", err.Error()) 581 581 - // do not quit though 582 582 - } else if defaultBranch == branchName { 583 583 - isDefault = true 584 584 - } 585 585 - 586 586 - resp := types.RepoBranchResponse{ 587 587 - Branch: types.Branch{ 588 588 - Reference: types.Reference{ 589 589 - Name: ref.Name().Short(), 590 590 - Hash: ref.Hash().String(), 591 591 - }, 592 592 - Commit: commit, 593 593 - IsDefault: isDefault, 594 594 - }, 595 595 - } 596 596 - 597 597 - writeJSON(w, resp) 598 598 - } 599 599 - 600 600 - func (h *Handle) Keys(w http.ResponseWriter, r *http.Request) { 601 601 - l := h.l.With("handler", "Keys") 602 602 - 603 603 - switch r.Method { 604 604 - case http.MethodGet: 605 605 - keys, err := h.db.GetAllPublicKeys() 606 606 - if err != nil { 607 607 - writeError(w, err.Error(), http.StatusInternalServerError) 608 608 - l.Error("getting public keys", "error", err.Error()) 609 609 - return 610 610 - } 611 611 - 612 612 - data := make([]map[string]any, 0) 613 613 - for _, key := range keys { 614 614 - j := key.JSON() 615 615 - data = append(data, j) 616 616 - } 617 617 - writeJSON(w, data) 618 618 - return 619 619 - 620 620 - case http.MethodPut: 621 621 - pk := db.PublicKey{} 622 622 - if err := json.NewDecoder(r.Body).Decode(&pk); err != nil { 623 623 - writeError(w, "invalid request body", http.StatusBadRequest) 624 624 - return 625 625 - } 626 626 - 627 627 - _, _, _, _, err := ssh.ParseAuthorizedKey([]byte(pk.Key)) 628 628 - if err != nil { 629 629 - writeError(w, "invalid pubkey", http.StatusBadRequest) 630 630 - } 631 631 - 632 632 - if err := h.db.AddPublicKey(pk); err != nil { 633 633 - writeError(w, err.Error(), http.StatusInternalServerError) 634 634 - l.Error("adding public key", "error", err.Error()) 635 635 - return 636 636 - } 637 637 - 638 638 - w.WriteHeader(http.StatusNoContent) 639 639 - return 640 640 - } 641 641 - } 642 642 - 643 643 - // func (h *Handle) RepoForkAheadBehind(w http.ResponseWriter, r *http.Request) { 644 644 - // l := h.l.With("handler", "RepoForkSync") 645 645 - // 646 646 - // data := struct { 647 647 - // Did string `json:"did"` 648 648 - // Source string `json:"source"` 649 649 - // Name string `json:"name,omitempty"` 650 650 - // HiddenRef string `json:"hiddenref"` 651 651 - // }{} 652 652 - // 653 653 - // if err := json.NewDecoder(r.Body).Decode(&data); err != nil { 654 654 - // writeError(w, "invalid request body", http.StatusBadRequest) 655 655 - // return 656 656 - // } 657 657 - // 658 658 - // did := data.Did 659 659 - // source := data.Source 660 660 - // 661 661 - // if did == "" || source == "" { 662 662 - // l.Error("invalid request body, empty did or name") 663 663 - // w.WriteHeader(http.StatusBadRequest) 664 664 - // return 665 665 - // } 666 666 - // 667 667 - // var name string 668 668 - // if data.Name != "" { 669 669 - // name = data.Name 670 670 - // } else { 671 671 - // name = filepath.Base(source) 672 672 - // } 673 673 - // 674 674 - // branch := chi.URLParam(r, "branch") 675 675 - // branch, _ = url.PathUnescape(branch) 676 676 - // 677 677 - // relativeRepoPath := filepath.Join(did, name) 678 678 - // repoPath, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, relativeRepoPath) 679 679 - // 680 680 - // gr, err := git.PlainOpen(repoPath) 681 681 - // if err != nil { 682 682 - // log.Println(err) 683 683 - // notFound(w) 684 684 - // return 685 685 - // } 686 686 - // 687 687 - // forkCommit, err := gr.ResolveRevision(branch) 688 688 - // if err != nil { 689 689 - // l.Error("error resolving ref revision", "msg", err.Error()) 690 690 - // writeError(w, fmt.Sprintf("error resolving revision %s", branch), http.StatusBadRequest) 691 691 - // return 692 692 - // } 693 693 - // 694 694 - // sourceCommit, err := gr.ResolveRevision(data.HiddenRef) 695 695 - // if err != nil { 696 696 - // l.Error("error resolving hidden ref revision", "msg", err.Error()) 697 697 - // writeError(w, fmt.Sprintf("error resolving revision %s", data.HiddenRef), http.StatusBadRequest) 698 698 - // return 699 699 - // } 700 700 - // 701 701 - // status := types.UpToDate 702 702 - // if forkCommit.Hash.String() != sourceCommit.Hash.String() { 703 703 - // isAncestor, err := forkCommit.IsAncestor(sourceCommit) 704 704 - // if err != nil { 705 705 - // log.Printf("error resolving whether %s is ancestor of %s: %s", branch, data.HiddenRef, err) 706 706 - // return 707 707 - // } 708 708 - // 709 709 - // if isAncestor { 710 710 - // status = types.FastForwardable 711 711 - // } else { 712 712 - // status = types.Conflict 713 713 - // } 714 714 - // } 715 715 - // 716 716 - // w.Header().Set("Content-Type", "application/json") 717 717 - // json.NewEncoder(w).Encode(types.AncestorCheckResponse{Status: status}) 718 718 - // } 719 719 - 720 720 - func (h *Handle) RepoLanguages(w http.ResponseWriter, r *http.Request) { 721 721 - repoPath, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 722 722 - ref := chi.URLParam(r, "ref") 723 723 - ref, _ = url.PathUnescape(ref) 724 724 - 725 725 - l := h.l.With("handler", "RepoLanguages") 726 726 - 727 727 - gr, err := git.Open(repoPath, ref) 728 728 - if err != nil { 729 729 - l.Error("opening repo", "error", err.Error()) 730 730 - notFound(w) 731 731 - return 732 732 - } 733 733 - 734 734 - ctx, cancel := context.WithTimeout(r.Context(), 1*time.Second) 735 735 - defer cancel() 736 736 - 737 737 - sizes, err := gr.AnalyzeLanguages(ctx) 738 738 - if err != nil { 739 739 - l.Error("failed to analyze languages", "error", err.Error()) 740 740 - writeError(w, err.Error(), http.StatusNoContent) 741 741 - return 742 742 - } 743 743 - 744 744 - resp := types.RepoLanguageResponse{Languages: sizes} 745 745 - 746 746 - writeJSON(w, resp) 747 747 - } 748 748 - 749 749 - // func (h *Handle) RepoForkSync(w http.ResponseWriter, r *http.Request) { 750 750 - // l := h.l.With("handler", "RepoForkSync") 751 751 - // 752 752 - // data := struct { 753 753 - // Did string `json:"did"` 754 754 - // Source string `json:"source"` 755 755 - // Name string `json:"name,omitempty"` 756 756 - // }{} 757 757 - // 758 758 - // if err := json.NewDecoder(r.Body).Decode(&data); err != nil { 759 759 - // writeError(w, "invalid request body", http.StatusBadRequest) 760 760 - // return 761 761 - // } 762 762 - // 763 763 - // did := data.Did 764 764 - // source := data.Source 765 765 - // 766 766 - // if did == "" || source == "" { 767 767 - // l.Error("invalid request body, empty did or name") 768 768 - // w.WriteHeader(http.StatusBadRequest) 769 769 - // return 770 770 - // } 771 771 - // 772 772 - // var name string 773 773 - // if data.Name != "" { 774 774 - // name = data.Name 775 775 - // } else { 776 776 - // name = filepath.Base(source) 777 777 - // } 778 778 - // 779 779 - // branch := chi.URLParam(r, "branch") 780 780 - // branch, _ = url.PathUnescape(branch) 781 781 - // 782 782 - // relativeRepoPath := filepath.Join(did, name) 783 783 - // repoPath, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, relativeRepoPath) 784 784 - // 785 785 - // gr, err := git.Open(repoPath, branch) 786 786 - // if err != nil { 787 787 - // log.Println(err) 788 788 - // notFound(w) 789 789 - // return 790 790 - // } 791 791 - // 792 792 - // err = gr.Sync() 793 793 - // if err != nil { 794 794 - // l.Error("error syncing repo fork", "error", err.Error()) 795 795 - // writeError(w, err.Error(), http.StatusInternalServerError) 796 796 - // return 797 797 - // } 798 798 - // 799 799 - // w.WriteHeader(http.StatusNoContent) 800 800 - // } 801 801 - 802 802 - // func (h *Handle) RepoFork(w http.ResponseWriter, r *http.Request) { 803 803 - // l := h.l.With("handler", "RepoFork") 804 804 - // 805 805 - // data := struct { 806 806 - // Did string `json:"did"` 807 807 - // Source string `json:"source"` 808 808 - // Name string `json:"name,omitempty"` 809 809 - // }{} 810 810 - // 811 811 - // if err := json.NewDecoder(r.Body).Decode(&data); err != nil { 812 812 - // writeError(w, "invalid request body", http.StatusBadRequest) 813 813 - // return 814 814 - // } 815 815 - // 816 816 - // did := data.Did 817 817 - // source := data.Source 818 818 - // 819 819 - // if did == "" || source == "" { 820 820 - // l.Error("invalid request body, empty did or name") 821 821 - // w.WriteHeader(http.StatusBadRequest) 822 822 - // return 823 823 - // } 824 824 - // 825 825 - // var name string 826 826 - // if data.Name != "" { 827 827 - // name = data.Name 828 828 - // } else { 829 829 - // name = filepath.Base(source) 830 830 - // } 831 831 - // 832 832 - // relativeRepoPath := filepath.Join(did, name) 833 833 - // repoPath, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, relativeRepoPath) 834 834 - // 835 835 - // err := git.Fork(repoPath, source) 836 836 - // if err != nil { 837 837 - // l.Error("forking repo", "error", err.Error()) 838 838 - // writeError(w, err.Error(), http.StatusInternalServerError) 839 839 - // return 840 840 - // } 841 841 - // 842 842 - // // add perms for this user to access the repo 843 843 - // err = h.e.AddRepo(did, rbac.ThisServer, relativeRepoPath) 844 844 - // if err != nil { 845 845 - // l.Error("adding repo permissions", "error", err.Error()) 846 846 - // writeError(w, err.Error(), http.StatusInternalServerError) 847 847 - // return 848 848 - // } 849 849 - // 850 850 - // hook.SetupRepo( 851 851 - // hook.Config( 852 852 - // hook.WithScanPath(h.c.Repo.ScanPath), 853 853 - // hook.WithInternalApi(h.c.Server.InternalListenAddr), 854 854 - // ), 855 855 - // repoPath, 856 856 - // ) 857 857 - // 858 858 - // w.WriteHeader(http.StatusNoContent) 859 859 - // } 860 860 - 861 861 - // func (h *Handle) RemoveRepo(w http.ResponseWriter, r *http.Request) { 862 862 - // l := h.l.With("handler", "RemoveRepo") 863 863 - // 864 864 - // data := struct { 865 865 - // Did string `json:"did"` 866 866 - // Name string `json:"name"` 867 867 - // }{} 868 868 - // 869 869 - // if err := json.NewDecoder(r.Body).Decode(&data); err != nil { 870 870 - // writeError(w, "invalid request body", http.StatusBadRequest) 871 871 - // return 872 872 - // } 873 873 - // 874 874 - // did := data.Did 875 875 - // name := data.Name 876 876 - // 877 877 - // if did == "" || name == "" { 878 878 - // l.Error("invalid request body, empty did or name") 879 879 - // w.WriteHeader(http.StatusBadRequest) 880 880 - // return 881 881 - // } 882 882 - // 883 883 - // relativeRepoPath := filepath.Join(did, name) 884 884 - // repoPath, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, relativeRepoPath) 885 885 - // err := os.RemoveAll(repoPath) 886 886 - // if err != nil { 887 887 - // l.Error("removing repo", "error", err.Error()) 888 888 - // writeError(w, err.Error(), http.StatusInternalServerError) 889 889 - // return 890 890 - // } 891 891 - // 892 892 - // w.WriteHeader(http.StatusNoContent) 893 893 - // 894 894 - // } 895 895 - 896 896 - // func (h *Handle) Merge(w http.ResponseWriter, r *http.Request) { 897 897 - // path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 898 898 - // 899 899 - // data := types.MergeRequest{} 900 900 - // 901 901 - // if err := json.NewDecoder(r.Body).Decode(&data); err != nil { 902 902 - // writeError(w, err.Error(), http.StatusBadRequest) 903 903 - // h.l.Error("git: failed to unmarshal json patch", "handler", "Merge", "error", err) 904 904 - // return 905 905 - // } 906 906 - // 907 907 - // mo := &git.MergeOptions{ 908 908 - // AuthorName: data.AuthorName, 909 909 - // AuthorEmail: data.AuthorEmail, 910 910 - // CommitBody: data.CommitBody, 911 911 - // CommitMessage: data.CommitMessage, 912 912 - // } 913 913 - // 914 914 - // patch := data.Patch 915 915 - // branch := data.Branch 916 916 - // gr, err := git.Open(path, branch) 917 917 - // if err != nil { 918 918 - // notFound(w) 919 919 - // return 920 920 - // } 921 921 - // 922 922 - // mo.FormatPatch = patchutil.IsFormatPatch(patch) 923 923 - // 924 924 - // if err := gr.MergeWithOptions([]byte(patch), branch, mo); err != nil { 925 925 - // var mergeErr *git.ErrMerge 926 926 - // if errors.As(err, &mergeErr) { 927 927 - // conflicts := make([]types.ConflictInfo, len(mergeErr.Conflicts)) 928 928 - // for i, conflict := range mergeErr.Conflicts { 929 929 - // conflicts[i] = types.ConflictInfo{ 930 930 - // Filename: conflict.Filename, 931 931 - // Reason: conflict.Reason, 932 932 - // } 933 933 - // } 934 934 - // response := types.MergeCheckResponse{ 935 935 - // IsConflicted: true, 936 936 - // Conflicts: conflicts, 937 937 - // Message: mergeErr.Message, 938 938 - // } 939 939 - // writeConflict(w, response) 940 940 - // h.l.Error("git: merge conflict", "handler", "Merge", "error", mergeErr) 941 941 - // } else { 942 942 - // writeError(w, err.Error(), http.StatusBadRequest) 943 943 - // h.l.Error("git: failed to merge", "handler", "Merge", "error", err.Error()) 944 944 - // } 945 945 - // return 946 946 - // } 947 947 - // 948 948 - // w.WriteHeader(http.StatusOK) 949 949 - // } 950 950 - 951 951 - // func (h *Handle) MergeCheck(w http.ResponseWriter, r *http.Request) { 952 952 - // path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 953 953 - // 954 954 - // var data struct { 955 955 - // Patch string `json:"patch"` 956 956 - // Branch string `json:"branch"` 957 957 - // } 958 958 - // 959 959 - // if err := json.NewDecoder(r.Body).Decode(&data); err != nil { 960 960 - // writeError(w, err.Error(), http.StatusBadRequest) 961 961 - // h.l.Error("git: failed to unmarshal json patch", "handler", "MergeCheck", "error", err) 962 962 - // return 963 963 - // } 964 964 - // 965 965 - // patch := data.Patch 966 966 - // branch := data.Branch 967 967 - // gr, err := git.Open(path, branch) 968 968 - // if err != nil { 969 969 - // notFound(w) 970 970 - // return 971 971 - // } 972 972 - // 973 973 - // err = gr.MergeCheck([]byte(patch), branch) 974 974 - // if err == nil { 975 975 - // response := types.MergeCheckResponse{ 976 976 - // IsConflicted: false, 977 977 - // } 978 978 - // writeJSON(w, response) 979 979 - // return 980 980 - // } 981 981 - // 982 982 - // var mergeErr *git.ErrMerge 983 983 - // if errors.As(err, &mergeErr) { 984 984 - // conflicts := make([]types.ConflictInfo, len(mergeErr.Conflicts)) 985 985 - // for i, conflict := range mergeErr.Conflicts { 986 986 - // conflicts[i] = types.ConflictInfo{ 987 987 - // Filename: conflict.Filename, 988 988 - // Reason: conflict.Reason, 989 989 - // } 990 990 - // } 991 991 - // response := types.MergeCheckResponse{ 992 992 - // IsConflicted: true, 993 993 - // Conflicts: conflicts, 994 994 - // Message: mergeErr.Message, 995 995 - // } 996 996 - // writeConflict(w, response) 997 997 - // h.l.Error("git: merge conflict", "handler", "MergeCheck", "error", mergeErr.Error()) 998 998 - // return 999 999 - // } 1000 1000 - // writeError(w, err.Error(), http.StatusInternalServerError) 1001 1001 - // h.l.Error("git: failed to check merge", "handler", "MergeCheck", "error", err.Error()) 1002 1002 - // } 1003 1003 - 1004 1004 - func (h *Handle) Compare(w http.ResponseWriter, r *http.Request) { 1005 1005 - rev1 := chi.URLParam(r, "rev1") 1006 1006 - rev1, _ = url.PathUnescape(rev1) 1007 1007 - 1008 1008 - rev2 := chi.URLParam(r, "rev2") 1009 1009 - rev2, _ = url.PathUnescape(rev2) 1010 1010 - 1011 1011 - l := h.l.With("handler", "Compare", "r1", rev1, "r2", rev2) 1012 1012 - 1013 1013 - path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 1014 1014 - gr, err := git.PlainOpen(path) 1015 1015 - if err != nil { 1016 1016 - notFound(w) 1017 1017 - return 1018 1018 - } 1019 1019 - 1020 1020 - commit1, err := gr.ResolveRevision(rev1) 1021 1021 - if err != nil { 1022 1022 - l.Error("error resolving revision 1", "msg", err.Error()) 1023 1023 - writeError(w, fmt.Sprintf("error resolving revision %s", rev1), http.StatusBadRequest) 1024 1024 - return 1025 1025 - } 1026 1026 - 1027 1027 - commit2, err := gr.ResolveRevision(rev2) 1028 1028 - if err != nil { 1029 1029 - l.Error("error resolving revision 2", "msg", err.Error()) 1030 1030 - writeError(w, fmt.Sprintf("error resolving revision %s", rev2), http.StatusBadRequest) 1031 1031 - return 1032 1032 - } 1033 1033 - 1034 1034 - rawPatch, formatPatch, err := gr.FormatPatch(commit1, commit2) 1035 1035 - if err != nil { 1036 1036 - l.Error("error comparing revisions", "msg", err.Error()) 1037 1037 - writeError(w, "error comparing revisions", http.StatusBadRequest) 1038 1038 - return 1039 1039 - } 1040 1040 - 1041 1041 - writeJSON(w, types.RepoFormatPatchResponse{ 1042 1042 - Rev1: commit1.Hash.String(), 1043 1043 - Rev2: commit2.Hash.String(), 1044 1044 - FormatPatch: formatPatch, 1045 1045 - Patch: rawPatch, 1046 1046 - }) 1047 1047 - } 1048 1048 - 1049 1049 - func (h *Handle) DefaultBranch(w http.ResponseWriter, r *http.Request) { 1050 1050 - l := h.l.With("handler", "DefaultBranch") 1051 1051 - path, _ := securejoin.SecureJoin(h.c.Repo.ScanPath, didPath(r)) 1052 1052 - 1053 1053 - gr, err := git.Open(path, "") 1054 1054 - if err != nil { 1055 1055 - notFound(w) 1056 1056 - return 1057 1057 - } 1058 1058 - 1059 1059 - branch, err := gr.FindMainBranch() 1060 1060 - if err != nil { 1061 1061 - writeError(w, err.Error(), http.StatusInternalServerError) 1062 1062 - l.Error("getting default branch", "error", err.Error()) 1063 1063 - return 1064 1064 - } 1065 1065 - 1066 1066 - writeJSON(w, types.RepoDefaultBranchResponse{ 1067 1067 - Branch: branch, 1068 1068 - }) 1069 1069 - }

+6 -6

knotserver/ingester.go

··· 24 24 "tangled.sh/tangled.sh/core/workflow" 25 25 ) 26 26 27 27 - func (h *Handle) processPublicKey(ctx context.Context, event *models.Event) error { 27 27 + func (h *Knot) processPublicKey(ctx context.Context, event *models.Event) error { 28 28 l := log.FromContext(ctx) 29 29 raw := json.RawMessage(event.Commit.Record) 30 30 did := event.Did ··· 46 46 return nil 47 47 } 48 48 49 49 - func (h *Handle) processKnotMember(ctx context.Context, event *models.Event) error { 49 49 + func (h *Knot) processKnotMember(ctx context.Context, event *models.Event) error { 50 50 l := log.FromContext(ctx) 51 51 raw := json.RawMessage(event.Commit.Record) 52 52 did := event.Did ··· 86 86 return nil 87 87 } 88 88 89 89 - func (h *Handle) processPull(ctx context.Context, event *models.Event) error { 89 89 + func (h *Knot) processPull(ctx context.Context, event *models.Event) error { 90 90 raw := json.RawMessage(event.Commit.Record) 91 91 did := event.Did 92 92 ··· 219 219 } 220 220 221 221 // duplicated from add collaborator 222 222 - func (h *Handle) processCollaborator(ctx context.Context, event *models.Event) error { 222 222 + func (h *Knot) processCollaborator(ctx context.Context, event *models.Event) error { 223 223 raw := json.RawMessage(event.Commit.Record) 224 224 did := event.Did 225 225 ··· 280 280 return h.fetchAndAddKeys(ctx, subjectId.DID.String()) 281 281 } 282 282 283 283 - func (h *Handle) fetchAndAddKeys(ctx context.Context, did string) error { 283 283 + func (h *Knot) fetchAndAddKeys(ctx context.Context, did string) error { 284 284 l := log.FromContext(ctx) 285 285 286 286 keysEndpoint, err := url.JoinPath(h.c.AppViewEndpoint, "keys", did) ··· 323 323 return nil 324 324 } 325 325 326 326 - func (h *Handle) processMessages(ctx context.Context, event *models.Event) error { 326 326 + func (h *Knot) processMessages(ctx context.Context, event *models.Event) error { 327 327 if event.Kind != models.EventKindCommit { 328 328 return nil 329 329 }

+20 -46

knotserver/routes.go knotserver/router.go

··· 19 19 "tangled.sh/tangled.sh/core/xrpc/serviceauth" 20 20 ) 21 21 22 22 - type Handle struct { 22 22 + type Knot struct { 23 23 c *config.Config 24 24 db *db.DB 25 25 jc *jetstream.JetstreamClient ··· 32 32 func Setup(ctx context.Context, c *config.Config, db *db.DB, e *rbac.Enforcer, jc *jetstream.JetstreamClient, l *slog.Logger, n *notifier.Notifier) (http.Handler, error) { 33 33 r := chi.NewRouter() 34 34 35 35 - h := Handle{ 35 35 + h := Knot{ 36 36 c: c, 37 37 db: db, 38 38 e: e, ··· 68 68 return nil, fmt.Errorf("failed to start jetstream: %w", err) 69 69 } 70 70 71 71 - r.Get("/", h.Index) 72 72 - r.Get("/capabilities", h.Capabilities) 73 73 - r.Get("/version", h.Version) 74 74 - r.Get("/owner", func(w http.ResponseWriter, r *http.Request) { 71 71 + r.Get("/", func(w http.ResponseWriter, r *http.Request) { 72 72 + w.Write([]byte("This is a knot server. More info at https://tangled.sh")) 73 73 + }) 74 74 + 75 75 + owner := func(w http.ResponseWriter, r *http.Request) { 75 76 w.Write([]byte(h.c.Server.Owner)) 76 76 - }) 77 77 + } 78 78 + // Deprecated: the sh.tangled.knot.owner xrpc call should be used instead 79 79 + r.Get("/owner", owner) 80 80 + 77 81 r.Route("/{did}", func(r chi.Router) { 78 78 - // Repo routes 79 82 r.Route("/{name}", func(r chi.Router) { 80 80 - 81 81 - r.Route("/languages", func(r chi.Router) { 82 82 - r.Get("/", h.RepoLanguages) 83 83 - r.Get("/{ref}", h.RepoLanguages) 84 84 - }) 85 85 - 86 86 - r.Get("/", h.RepoIndex) 83 83 + // routes for git operations 87 84 r.Get("/info/refs", h.InfoRefs) 88 85 r.Post("/git-upload-pack", h.UploadPack) 89 86 r.Post("/git-receive-pack", h.ReceivePack) 90 90 - r.Get("/compare/{rev1}/{rev2}", h.Compare) // git diff-tree compare of two objects 91 91 - 92 92 - r.Route("/tree/{ref}", func(r chi.Router) { 93 93 - r.Get("/", h.RepoIndex) 94 94 - r.Get("/*", h.RepoTree) 95 95 - }) 96 96 - 97 97 - r.Route("/blob/{ref}", func(r chi.Router) { 98 98 - r.Get("/*", h.Blob) 99 99 - }) 100 100 - 101 101 - r.Route("/raw/{ref}", func(r chi.Router) { 102 102 - r.Get("/*", h.BlobRaw) 103 103 - }) 104 104 - 105 105 - r.Get("/log/{ref}", h.Log) 106 106 - r.Get("/archive/{file}", h.Archive) 107 107 - r.Get("/commit/{ref}", h.Diff) 108 108 - r.Get("/tags", h.Tags) 109 109 - r.Route("/branches", func(r chi.Router) { 110 110 - r.Get("/", h.Branches) 111 111 - r.Get("/{branch}", h.Branch) 112 112 - r.Get("/default", h.DefaultBranch) 113 113 - }) 114 87 }) 115 88 }) 116 89 117 90 // xrpc apis 118 118 - r.Mount("/xrpc", h.XrpcRouter()) 91 91 + r.Route("/xrpc", func(r chi.Router) { 92 92 + r.Get("/_health", h.Version) 93 93 + r.Get("/sh.tangled.knot.owner", owner) 94 94 + r.Mount("/", h.XrpcRouter()) 95 95 + }) 119 96 120 97 // Socket that streams git oplogs 121 98 r.Get("/events", h.Events) 122 99 123 123 - // All public keys on the knot. 124 124 - r.Get("/keys", h.Keys) 125 125 - 126 100 return r, nil 127 101 } 128 102 129 129 - func (h *Handle) XrpcRouter() http.Handler { 103 103 + func (h *Knot) XrpcRouter() http.Handler { 130 104 logger := tlog.New("knots") 131 105 132 106 serviceAuth := serviceauth.NewServiceAuth(h.l, h.resolver, h.c.Server.Did().String()) ··· 147 121 // version is set during build time. 148 122 var version string 149 123 150 150 - func (h *Handle) Version(w http.ResponseWriter, r *http.Request) { 124 124 + func (h *Knot) Version(w http.ResponseWriter, r *http.Request) { 151 125 if version == "" { 152 126 info, ok := debug.ReadBuildInfo() 153 127 if !ok { ··· 192 166 fmt.Fprintf(w, "knotserver/%s", version) 193 167 } 194 168 195 195 - func (h *Handle) configureOwner() error { 169 169 + func (h *Knot) configureOwner() error { 196 170 cfgOwner := h.c.Server.Owner 197 171 198 172 rbacDomain := "thisserver"