commit fe72fb7c07c9dc654ea0e8b146dc0cfb537a2605 · althaea.zone/core

+1 -10

knotserver/xrpc/list_keys.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 "strconv" 7 ··· 46 response.Cursor = &nextCursor 47 } 48 49 - w.Header().Set("Content-Type", "application/json") 50 - if err := json.NewEncoder(w).Encode(response); err != nil { 51 - x.Logger.Error("failed to encode response", "error", err) 52 - writeError(w, xrpcerr.NewXrpcError( 53 - xrpcerr.WithTag("InternalServerError"), 54 - xrpcerr.WithMessage("failed to encode response"), 55 - ), http.StatusInternalServerError) 56 - return 57 - } 58 }

··· 1 package xrpc 2 3 import ( 4 "net/http" 5 "strconv" 6 ··· 45 response.Cursor = &nextCursor 46 } 47 48 + writeJson(w, response) 49 }

+1 -10

knotserver/xrpc/owner.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 7 "tangled.sh/tangled.sh/core/api/tangled" ··· 19 Owner: owner, 20 } 21 22 - w.Header().Set("Content-Type", "application/json") 23 - if err := json.NewEncoder(w).Encode(response); err != nil { 24 - x.Logger.Error("failed to encode response", "error", err) 25 - writeError(w, xrpcerr.NewXrpcError( 26 - xrpcerr.WithTag("InternalServerError"), 27 - xrpcerr.WithMessage("failed to encode response"), 28 - ), http.StatusInternalServerError) 29 - return 30 - } 31 }

··· 1 package xrpc 2 3 import ( 4 "net/http" 5 6 "tangled.sh/tangled.sh/core/api/tangled" ··· 18 Owner: owner, 19 } 20 21 + writeJson(w, response) 22 }

+1 -10

knotserver/xrpc/repo_blob.go

··· 3 import ( 4 "crypto/sha256" 5 "encoding/base64" 6 - "encoding/json" 7 "fmt" 8 "net/http" 9 "path/filepath" ··· 124 response.MimeType = &mimeType 125 } 126 127 - w.Header().Set("Content-Type", "application/json") 128 - if err := json.NewEncoder(w).Encode(response); err != nil { 129 - x.Logger.Error("failed to encode response", "error", err) 130 - writeError(w, xrpcerr.NewXrpcError( 131 - xrpcerr.WithTag("InternalServerError"), 132 - xrpcerr.WithMessage("failed to encode response"), 133 - ), http.StatusInternalServerError) 134 - return 135 - } 136 } 137 138 // isTextualMimeType returns true if the MIME type represents textual content

··· 3 import ( 4 "crypto/sha256" 5 "encoding/base64" 6 "fmt" 7 "net/http" 8 "path/filepath" ··· 123 response.MimeType = &mimeType 124 } 125 126 + writeJson(w, response) 127 } 128 129 // isTextualMimeType returns true if the MIME type represents textual content

+1 -10

knotserver/xrpc/repo_branch.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 "net/url" 7 "time" ··· 82 When: commit.Author.When.Format(time.RFC3339), 83 } 84 85 - w.Header().Set("Content-Type", "application/json") 86 - if err := json.NewEncoder(w).Encode(response); err != nil { 87 - x.Logger.Error("failed to encode response", "error", err) 88 - writeError(w, xrpcerr.NewXrpcError( 89 - xrpcerr.WithTag("InternalServerError"), 90 - xrpcerr.WithMessage("failed to encode response"), 91 - ), http.StatusInternalServerError) 92 - return 93 - } 94 }

··· 1 package xrpc 2 3 import ( 4 "net/http" 5 "net/url" 6 "time" ··· 81 When: commit.Author.When.Format(time.RFC3339), 82 } 83 84 + writeJson(w, response) 85 }

+1 -11

knotserver/xrpc/repo_branches.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 "strconv" 7 ··· 53 Branches: paginatedBranches, 54 } 55 56 - // Write JSON response directly 57 - w.Header().Set("Content-Type", "application/json") 58 - if err := json.NewEncoder(w).Encode(response); err != nil { 59 - x.Logger.Error("failed to encode response", "error", err) 60 - writeError(w, xrpcerr.NewXrpcError( 61 - xrpcerr.WithTag("InternalServerError"), 62 - xrpcerr.WithMessage("failed to encode response"), 63 - ), http.StatusInternalServerError) 64 - return 65 - } 66 }

··· 1 package xrpc 2 3 import ( 4 "net/http" 5 "strconv" 6 ··· 52 Branches: paginatedBranches, 53 } 54 55 + writeJson(w, response) 56 }

+2 -11

knotserver/xrpc/repo_compare.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "fmt" 6 "net/http" 7 ··· 72 return 73 } 74 75 - resp := types.RepoFormatPatchResponse{ 76 Rev1: commit1.Hash.String(), 77 Rev2: commit2.Hash.String(), 78 FormatPatch: formatPatch, 79 Patch: rawPatch, 80 } 81 82 - w.Header().Set("Content-Type", "application/json") 83 - if err := json.NewEncoder(w).Encode(resp); err != nil { 84 - x.Logger.Error("failed to encode response", "error", err) 85 - writeError(w, xrpcerr.NewXrpcError( 86 - xrpcerr.WithTag("InternalServerError"), 87 - xrpcerr.WithMessage("failed to encode response"), 88 - ), http.StatusInternalServerError) 89 - return 90 - } 91 }

··· 1 package xrpc 2 3 import ( 4 "fmt" 5 "net/http" 6 ··· 71 return 72 } 73 74 + response := types.RepoFormatPatchResponse{ 75 Rev1: commit1.Hash.String(), 76 Rev2: commit2.Hash.String(), 77 FormatPatch: formatPatch, 78 Patch: rawPatch, 79 } 80 81 + writeJson(w, response) 82 }

+2 -11

knotserver/xrpc/repo_diff.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 7 "tangled.sh/tangled.sh/core/knotserver/git" ··· 33 return 34 } 35 36 - resp := types.RepoCommitResponse{ 37 Ref: ref, 38 Diff: diff, 39 } 40 41 - w.Header().Set("Content-Type", "application/json") 42 - if err := json.NewEncoder(w).Encode(resp); err != nil { 43 - x.Logger.Error("failed to encode response", "error", err) 44 - writeError(w, xrpcerr.NewXrpcError( 45 - xrpcerr.WithTag("InternalServerError"), 46 - xrpcerr.WithMessage("failed to encode response"), 47 - ), http.StatusInternalServerError) 48 - return 49 - } 50 }

··· 1 package xrpc 2 3 import ( 4 "net/http" 5 6 "tangled.sh/tangled.sh/core/knotserver/git" ··· 32 return 33 } 34 35 + response := types.RepoCommitResponse{ 36 Ref: ref, 37 Diff: diff, 38 } 39 40 + writeJson(w, response) 41 }

+1 -10

knotserver/xrpc/repo_get_default_branch.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 "time" 7 ··· 36 When: time.UnixMicro(0).Format(time.RFC3339), 37 } 38 39 - w.Header().Set("Content-Type", "application/json") 40 - if err := json.NewEncoder(w).Encode(response); err != nil { 41 - x.Logger.Error("failed to encode response", "error", err) 42 - writeError(w, xrpcerr.NewXrpcError( 43 - xrpcerr.WithTag("InternalServerError"), 44 - xrpcerr.WithMessage("failed to encode response"), 45 - ), http.StatusInternalServerError) 46 - return 47 - } 48 }

··· 1 package xrpc 2 3 import ( 4 "net/http" 5 "time" 6 ··· 35 When: time.UnixMicro(0).Format(time.RFC3339), 36 } 37 38 + writeJson(w, response) 39 }

+1 -10

knotserver/xrpc/repo_languages.go

··· 2 3 import ( 4 "context" 5 - "encoding/json" 6 "math" 7 "net/http" 8 "time" ··· 73 response.TotalFiles = &totalFiles 74 } 75 76 - w.Header().Set("Content-Type", "application/json") 77 - if err := json.NewEncoder(w).Encode(response); err != nil { 78 - x.Logger.Error("failed to encode response", "error", err) 79 - writeError(w, xrpcerr.NewXrpcError( 80 - xrpcerr.WithTag("InternalServerError"), 81 - xrpcerr.WithMessage("failed to encode response"), 82 - ), http.StatusInternalServerError) 83 - return 84 - } 85 }

··· 2 3 import ( 4 "context" 5 "math" 6 "net/http" 7 "time" ··· 72 response.TotalFiles = &totalFiles 73 } 74 75 + writeJson(w, response) 76 }

+1 -11

knotserver/xrpc/repo_log.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 "strconv" 7 ··· 78 79 response.Log = true 80 81 - // Write JSON response directly 82 - w.Header().Set("Content-Type", "application/json") 83 - if err := json.NewEncoder(w).Encode(response); err != nil { 84 - x.Logger.Error("failed to encode response", "error", err) 85 - writeError(w, xrpcerr.NewXrpcError( 86 - xrpcerr.WithTag("InternalServerError"), 87 - xrpcerr.WithMessage("failed to encode response"), 88 - ), http.StatusInternalServerError) 89 - return 90 - } 91 }

··· 1 package xrpc 2 3 import ( 4 "net/http" 5 "strconv" 6 ··· 77 78 response.Log = true 79 80 + writeJson(w, response) 81 }

+1 -11

knotserver/xrpc/repo_tags.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 "strconv" 7 ··· 83 Tags: paginatedTags, 84 } 85 86 - // Write JSON response directly 87 - w.Header().Set("Content-Type", "application/json") 88 - if err := json.NewEncoder(w).Encode(response); err != nil { 89 - x.Logger.Error("failed to encode response", "error", err) 90 - writeError(w, xrpcerr.NewXrpcError( 91 - xrpcerr.WithTag("InternalServerError"), 92 - xrpcerr.WithMessage("failed to encode response"), 93 - ), http.StatusInternalServerError) 94 - return 95 - } 96 }

··· 1 package xrpc 2 3 import ( 4 "net/http" 5 "strconv" 6 ··· 82 Tags: paginatedTags, 83 } 84 85 + writeJson(w, response) 86 }

+1 -10

knotserver/xrpc/repo_tree.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "net/http" 6 "path/filepath" 7 "time" ··· 86 Files: treeEntries, 87 } 88 89 - w.Header().Set("Content-Type", "application/json") 90 - if err := json.NewEncoder(w).Encode(response); err != nil { 91 - x.Logger.Error("failed to encode response", "error", err) 92 - writeError(w, xrpcerr.NewXrpcError( 93 - xrpcerr.WithTag("InternalServerError"), 94 - xrpcerr.WithMessage("failed to encode response"), 95 - ), http.StatusInternalServerError) 96 - return 97 - } 98 }

··· 1 package xrpc 2 3 import ( 4 "net/http" 5 "path/filepath" 6 "time" ··· 85 Files: treeEntries, 86 } 87 88 + writeJson(w, response) 89 }

+1 -11

knotserver/xrpc/version.go

··· 1 package xrpc 2 3 import ( 4 - "encoding/json" 5 "fmt" 6 "net/http" 7 "runtime/debug" 8 9 "tangled.sh/tangled.sh/core/api/tangled" 10 - xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors" 11 ) 12 13 // version is set during build time. ··· 58 Version: version, 59 } 60 61 - w.Header().Set("Content-Type", "application/json") 62 - if err := json.NewEncoder(w).Encode(response); err != nil { 63 - x.Logger.Error("failed to encode response", "error", err) 64 - writeError(w, xrpcerr.NewXrpcError( 65 - xrpcerr.WithTag("InternalServerError"), 66 - xrpcerr.WithMessage("failed to encode response"), 67 - ), http.StatusInternalServerError) 68 - return 69 - } 70 }

··· 1 package xrpc 2 3 import ( 4 "fmt" 5 "net/http" 6 "runtime/debug" 7 8 "tangled.sh/tangled.sh/core/api/tangled" 9 ) 10 11 // version is set during build time. ··· 56 Version: version, 57 } 58 59 + writeJson(w, response) 60 }

+8

knotserver/xrpc/xrpc.go

··· 117 w.WriteHeader(status) 118 json.NewEncoder(w).Encode(e) 119 }

··· 117 w.WriteHeader(status) 118 json.NewEncoder(w).Encode(e) 119 } 120 + 121 + func writeJson(w http.ResponseWriter, response any) { 122 + w.Header().Set("Content-Type", "application/json") 123 + if err := json.NewEncoder(w).Encode(response); err != nil { 124 + writeError(w, xrpcerr.GenericError(err), http.StatusInternalServerError) 125 + return 126 + } 127 + }