+1

appview/signer.go

··· 1 1 +

-473

appview/state/signer.go

··· 1 1 - package state 2 2 - 3 3 - import ( 4 4 - "bytes" 5 5 - "crypto/hmac" 6 6 - "crypto/sha256" 7 7 - "encoding/hex" 8 8 - "encoding/json" 9 9 - "fmt" 10 10 - "io" 11 11 - "log" 12 12 - "net/http" 13 13 - "net/url" 14 14 - "strconv" 15 15 - "time" 16 16 - 17 17 - "tangled.sh/tangled.sh/core/types" 18 18 - ) 19 19 - 20 20 - type SignerTransport struct { 21 21 - Secret string 22 22 - } 23 23 - 24 24 - func (s SignerTransport) RoundTrip(req *http.Request) (*http.Response, error) { 25 25 - timestamp := time.Now().Format(time.RFC3339) 26 26 - mac := hmac.New(sha256.New, []byte(s.Secret)) 27 27 - message := req.Method + req.URL.Path + timestamp 28 28 - mac.Write([]byte(message)) 29 29 - signature := hex.EncodeToString(mac.Sum(nil)) 30 30 - req.Header.Set("X-Signature", signature) 31 31 - req.Header.Set("X-Timestamp", timestamp) 32 32 - return http.DefaultTransport.RoundTrip(req) 33 33 - } 34 34 - 35 35 - type SignedClient struct { 36 36 - Secret string 37 37 - Url *url.URL 38 38 - client *http.Client 39 39 - } 40 40 - 41 41 - func NewSignedClient(domain, secret string, dev bool) (*SignedClient, error) { 42 42 - client := &http.Client{ 43 43 - Timeout: 5 * time.Second, 44 44 - Transport: SignerTransport{ 45 45 - Secret: secret, 46 46 - }, 47 47 - } 48 48 - 49 49 - scheme := "https" 50 50 - if dev { 51 51 - scheme = "http" 52 52 - } 53 53 - url, err := url.Parse(fmt.Sprintf("%s://%s", scheme, domain)) 54 54 - if err != nil { 55 55 - return nil, err 56 56 - } 57 57 - 58 58 - signedClient := &SignedClient{ 59 59 - Secret: secret, 60 60 - client: client, 61 61 - Url: url, 62 62 - } 63 63 - 64 64 - return signedClient, nil 65 65 - } 66 66 - 67 67 - func (s *SignedClient) newRequest(method, endpoint string, body []byte) (*http.Request, error) { 68 68 - return http.NewRequest(method, s.Url.JoinPath(endpoint).String(), bytes.NewReader(body)) 69 69 - } 70 70 - 71 71 - func (s *SignedClient) Init(did string) (*http.Response, error) { 72 72 - const ( 73 73 - Method = "POST" 74 74 - Endpoint = "/init" 75 75 - ) 76 76 - 77 77 - body, _ := json.Marshal(map[string]any{ 78 78 - "did": did, 79 79 - }) 80 80 - 81 81 - req, err := s.newRequest(Method, Endpoint, body) 82 82 - if err != nil { 83 83 - return nil, err 84 84 - } 85 85 - 86 86 - return s.client.Do(req) 87 87 - } 88 88 - 89 89 - func (s *SignedClient) NewRepo(did, repoName, defaultBranch string) (*http.Response, error) { 90 90 - const ( 91 91 - Method = "PUT" 92 92 - Endpoint = "/repo/new" 93 93 - ) 94 94 - 95 95 - body, _ := json.Marshal(map[string]any{ 96 96 - "did": did, 97 97 - "name": repoName, 98 98 - "default_branch": defaultBranch, 99 99 - }) 100 100 - 101 101 - req, err := s.newRequest(Method, Endpoint, body) 102 102 - if err != nil { 103 103 - return nil, err 104 104 - } 105 105 - 106 106 - return s.client.Do(req) 107 107 - } 108 108 - 109 109 - func (s *SignedClient) ForkRepo(ownerDid, source, name string) (*http.Response, error) { 110 110 - const ( 111 111 - Method = "POST" 112 112 - Endpoint = "/repo/fork" 113 113 - ) 114 114 - 115 115 - body, _ := json.Marshal(map[string]any{ 116 116 - "did": ownerDid, 117 117 - "source": source, 118 118 - "name": name, 119 119 - }) 120 120 - 121 121 - req, err := s.newRequest(Method, Endpoint, body) 122 122 - if err != nil { 123 123 - return nil, err 124 124 - } 125 125 - 126 126 - return s.client.Do(req) 127 127 - } 128 128 - 129 129 - func (s *SignedClient) RemoveRepo(did, repoName string) (*http.Response, error) { 130 130 - const ( 131 131 - Method = "DELETE" 132 132 - Endpoint = "/repo" 133 133 - ) 134 134 - 135 135 - body, _ := json.Marshal(map[string]any{ 136 136 - "did": did, 137 137 - "name": repoName, 138 138 - }) 139 139 - 140 140 - req, err := s.newRequest(Method, Endpoint, body) 141 141 - if err != nil { 142 142 - return nil, err 143 143 - } 144 144 - 145 145 - return s.client.Do(req) 146 146 - } 147 147 - 148 148 - func (s *SignedClient) AddMember(did string) (*http.Response, error) { 149 149 - const ( 150 150 - Method = "PUT" 151 151 - Endpoint = "/member/add" 152 152 - ) 153 153 - 154 154 - body, _ := json.Marshal(map[string]any{ 155 155 - "did": did, 156 156 - }) 157 157 - 158 158 - req, err := s.newRequest(Method, Endpoint, body) 159 159 - if err != nil { 160 160 - return nil, err 161 161 - } 162 162 - 163 163 - return s.client.Do(req) 164 164 - } 165 165 - 166 166 - func (s *SignedClient) SetDefaultBranch(ownerDid, repoName, branch string) (*http.Response, error) { 167 167 - const ( 168 168 - Method = "PUT" 169 169 - ) 170 170 - endpoint := fmt.Sprintf("/%s/%s/branches/default", ownerDid, repoName) 171 171 - 172 172 - body, _ := json.Marshal(map[string]any{ 173 173 - "branch": branch, 174 174 - }) 175 175 - 176 176 - req, err := s.newRequest(Method, endpoint, body) 177 177 - if err != nil { 178 178 - return nil, err 179 179 - } 180 180 - 181 181 - return s.client.Do(req) 182 182 - } 183 183 - 184 184 - func (s *SignedClient) AddCollaborator(ownerDid, repoName, memberDid string) (*http.Response, error) { 185 185 - const ( 186 186 - Method = "POST" 187 187 - ) 188 188 - endpoint := fmt.Sprintf("/%s/%s/collaborator/add", ownerDid, repoName) 189 189 - 190 190 - body, _ := json.Marshal(map[string]any{ 191 191 - "did": memberDid, 192 192 - }) 193 193 - 194 194 - req, err := s.newRequest(Method, endpoint, body) 195 195 - if err != nil { 196 196 - return nil, err 197 197 - } 198 198 - 199 199 - return s.client.Do(req) 200 200 - } 201 201 - 202 202 - func (s *SignedClient) Merge( 203 203 - patch []byte, 204 204 - ownerDid, targetRepo, branch, commitMessage, commitBody, authorName, authorEmail string, 205 205 - ) (*http.Response, error) { 206 206 - const ( 207 207 - Method = "POST" 208 208 - ) 209 209 - endpoint := fmt.Sprintf("/%s/%s/merge", ownerDid, targetRepo) 210 210 - 211 211 - mr := types.MergeRequest{ 212 212 - Branch: branch, 213 213 - CommitMessage: commitMessage, 214 214 - CommitBody: commitBody, 215 215 - AuthorName: authorName, 216 216 - AuthorEmail: authorEmail, 217 217 - Patch: string(patch), 218 218 - } 219 219 - 220 220 - body, _ := json.Marshal(mr) 221 221 - 222 222 - req, err := s.newRequest(Method, endpoint, body) 223 223 - if err != nil { 224 224 - return nil, err 225 225 - } 226 226 - 227 227 - return s.client.Do(req) 228 228 - } 229 229 - 230 230 - func (s *SignedClient) MergeCheck(patch []byte, ownerDid, targetRepo, branch string) (*http.Response, error) { 231 231 - const ( 232 232 - Method = "POST" 233 233 - ) 234 234 - endpoint := fmt.Sprintf("/%s/%s/merge/check", ownerDid, targetRepo) 235 235 - 236 236 - body, _ := json.Marshal(map[string]any{ 237 237 - "patch": string(patch), 238 238 - "branch": branch, 239 239 - }) 240 240 - 241 241 - req, err := s.newRequest(Method, endpoint, body) 242 242 - if err != nil { 243 243 - return nil, err 244 244 - } 245 245 - 246 246 - return s.client.Do(req) 247 247 - } 248 248 - 249 249 - func (s *SignedClient) NewHiddenRef(ownerDid, targetRepo, forkBranch, remoteBranch string) (*http.Response, error) { 250 250 - const ( 251 251 - Method = "POST" 252 252 - ) 253 253 - endpoint := fmt.Sprintf("/%s/%s/hidden-ref/%s/%s", ownerDid, targetRepo, url.PathEscape(forkBranch), url.PathEscape(remoteBranch)) 254 254 - 255 255 - req, err := s.newRequest(Method, endpoint, nil) 256 256 - if err != nil { 257 257 - return nil, err 258 258 - } 259 259 - 260 260 - return s.client.Do(req) 261 261 - } 262 262 - 263 263 - type UnsignedClient struct { 264 264 - Url *url.URL 265 265 - client *http.Client 266 266 - } 267 267 - 268 268 - func NewUnsignedClient(domain string, dev bool) (*UnsignedClient, error) { 269 269 - client := &http.Client{ 270 270 - Timeout: 5 * time.Second, 271 271 - } 272 272 - 273 273 - scheme := "https" 274 274 - if dev { 275 275 - scheme = "http" 276 276 - } 277 277 - url, err := url.Parse(fmt.Sprintf("%s://%s", scheme, domain)) 278 278 - if err != nil { 279 279 - return nil, err 280 280 - } 281 281 - 282 282 - unsignedClient := &UnsignedClient{ 283 283 - client: client, 284 284 - Url: url, 285 285 - } 286 286 - 287 287 - return unsignedClient, nil 288 288 - } 289 289 - 290 290 - func (us *UnsignedClient) newRequest(method, endpoint string, query url.Values, body []byte) (*http.Request, error) { 291 291 - reqUrl := us.Url.JoinPath(endpoint) 292 292 - 293 293 - // add query parameters 294 294 - if query != nil { 295 295 - reqUrl.RawQuery = query.Encode() 296 296 - } 297 297 - 298 298 - return http.NewRequest(method, reqUrl.String(), bytes.NewReader(body)) 299 299 - } 300 300 - 301 301 - func (us *UnsignedClient) Index(ownerDid, repoName, ref string) (*http.Response, error) { 302 302 - const ( 303 303 - Method = "GET" 304 304 - ) 305 305 - 306 306 - endpoint := fmt.Sprintf("/%s/%s/tree/%s", ownerDid, repoName, ref) 307 307 - if ref == "" { 308 308 - endpoint = fmt.Sprintf("/%s/%s", ownerDid, repoName) 309 309 - } 310 310 - 311 311 - req, err := us.newRequest(Method, endpoint, nil, nil) 312 312 - if err != nil { 313 313 - return nil, err 314 314 - } 315 315 - 316 316 - return us.client.Do(req) 317 317 - } 318 318 - 319 319 - func (us *UnsignedClient) Log(ownerDid, repoName, ref string, page int) (*http.Response, error) { 320 320 - const ( 321 321 - Method = "GET" 322 322 - ) 323 323 - 324 324 - endpoint := fmt.Sprintf("/%s/%s/log/%s", ownerDid, repoName, url.PathEscape(ref)) 325 325 - 326 326 - query := url.Values{} 327 327 - query.Add("page", strconv.Itoa(page)) 328 328 - query.Add("per_page", strconv.Itoa(60)) 329 329 - 330 330 - req, err := us.newRequest(Method, endpoint, query, nil) 331 331 - if err != nil { 332 332 - return nil, err 333 333 - } 334 334 - 335 335 - return us.client.Do(req) 336 336 - } 337 337 - 338 338 - func (us *UnsignedClient) Branches(ownerDid, repoName string) (*http.Response, error) { 339 339 - const ( 340 340 - Method = "GET" 341 341 - ) 342 342 - 343 343 - endpoint := fmt.Sprintf("/%s/%s/branches", ownerDid, repoName) 344 344 - 345 345 - req, err := us.newRequest(Method, endpoint, nil, nil) 346 346 - if err != nil { 347 347 - return nil, err 348 348 - } 349 349 - 350 350 - return us.client.Do(req) 351 351 - } 352 352 - 353 353 - func (us *UnsignedClient) Tags(ownerDid, repoName string) (*http.Response, error) { 354 354 - const ( 355 355 - Method = "GET" 356 356 - ) 357 357 - 358 358 - endpoint := fmt.Sprintf("/%s/%s/tags", ownerDid, repoName) 359 359 - 360 360 - req, err := us.newRequest(Method, endpoint, nil, nil) 361 361 - if err != nil { 362 362 - return nil, err 363 363 - } 364 364 - 365 365 - return us.client.Do(req) 366 366 - } 367 367 - 368 368 - func (us *UnsignedClient) Branch(ownerDid, repoName, branch string) (*http.Response, error) { 369 369 - const ( 370 370 - Method = "GET" 371 371 - ) 372 372 - 373 373 - endpoint := fmt.Sprintf("/%s/%s/branches/%s", ownerDid, repoName, url.PathEscape(branch)) 374 374 - 375 375 - req, err := us.newRequest(Method, endpoint, nil, nil) 376 376 - if err != nil { 377 377 - return nil, err 378 378 - } 379 379 - 380 380 - return us.client.Do(req) 381 381 - } 382 382 - 383 383 - func (us *UnsignedClient) DefaultBranch(ownerDid, repoName string) (*types.RepoDefaultBranchResponse, error) { 384 384 - const ( 385 385 - Method = "GET" 386 386 - ) 387 387 - 388 388 - endpoint := fmt.Sprintf("/%s/%s/branches/default", ownerDid, repoName) 389 389 - 390 390 - req, err := us.newRequest(Method, endpoint, nil, nil) 391 391 - if err != nil { 392 392 - return nil, err 393 393 - } 394 394 - 395 395 - resp, err := us.client.Do(req) 396 396 - if err != nil { 397 397 - return nil, err 398 398 - } 399 399 - defer resp.Body.Close() 400 400 - 401 401 - var defaultBranch types.RepoDefaultBranchResponse 402 402 - if err := json.NewDecoder(resp.Body).Decode(&defaultBranch); err != nil { 403 403 - return nil, err 404 404 - } 405 405 - 406 406 - return &defaultBranch, nil 407 407 - } 408 408 - 409 409 - func (us *UnsignedClient) Capabilities() (*types.Capabilities, error) { 410 410 - const ( 411 411 - Method = "GET" 412 412 - Endpoint = "/capabilities" 413 413 - ) 414 414 - 415 415 - req, err := us.newRequest(Method, Endpoint, nil, nil) 416 416 - if err != nil { 417 417 - return nil, err 418 418 - } 419 419 - 420 420 - resp, err := us.client.Do(req) 421 421 - if err != nil { 422 422 - return nil, err 423 423 - } 424 424 - defer resp.Body.Close() 425 425 - 426 426 - var capabilities types.Capabilities 427 427 - if err := json.NewDecoder(resp.Body).Decode(&capabilities); err != nil { 428 428 - return nil, err 429 429 - } 430 430 - 431 431 - return &capabilities, nil 432 432 - } 433 433 - 434 434 - func (us *UnsignedClient) Compare(ownerDid, repoName, rev1, rev2 string) (*types.RepoFormatPatchResponse, error) { 435 435 - const ( 436 436 - Method = "GET" 437 437 - ) 438 438 - 439 439 - endpoint := fmt.Sprintf("/%s/%s/compare/%s/%s", ownerDid, repoName, url.PathEscape(rev1), url.PathEscape(rev2)) 440 440 - 441 441 - req, err := us.newRequest(Method, endpoint, nil, nil) 442 442 - if err != nil { 443 443 - return nil, fmt.Errorf("Failed to create request.") 444 444 - } 445 445 - 446 446 - compareResp, err := us.client.Do(req) 447 447 - if err != nil { 448 448 - return nil, fmt.Errorf("Failed to create request.") 449 449 - } 450 450 - defer compareResp.Body.Close() 451 451 - 452 452 - switch compareResp.StatusCode { 453 453 - case 404: 454 454 - case 400: 455 455 - return nil, fmt.Errorf("Branch comparisons not supported on this knot.") 456 456 - } 457 457 - 458 458 - respBody, err := io.ReadAll(compareResp.Body) 459 459 - if err != nil { 460 460 - log.Println("failed to compare across branches") 461 461 - return nil, fmt.Errorf("Failed to compare branches.") 462 462 - } 463 463 - defer compareResp.Body.Close() 464 464 - 465 465 - var formatPatchResponse types.RepoFormatPatchResponse 466 466 - err = json.Unmarshal(respBody, &formatPatchResponse) 467 467 - if err != nil { 468 468 - log.Println("failed to unmarshal format-patch response", err) 469 469 - return nil, fmt.Errorf("failed to compare branches.") 470 470 - } 471 471 - 472 472 - return &formatPatchResponse, nil 473 473 - }

+258

knotclient/signed.go

··· 1 1 + package knotclient 2 2 + 3 3 + import ( 4 4 + "bytes" 5 5 + "crypto/hmac" 6 6 + "crypto/sha256" 7 7 + "encoding/hex" 8 8 + "encoding/json" 9 9 + "fmt" 10 10 + "net/http" 11 11 + "net/url" 12 12 + "time" 13 13 + 14 14 + "tangled.sh/tangled.sh/core/types" 15 15 + ) 16 16 + 17 17 + type SignerTransport struct { 18 18 + Secret string 19 19 + } 20 20 + 21 21 + func (s SignerTransport) RoundTrip(req *http.Request) (*http.Response, error) { 22 22 + timestamp := time.Now().Format(time.RFC3339) 23 23 + mac := hmac.New(sha256.New, []byte(s.Secret)) 24 24 + message := req.Method + req.URL.Path + timestamp 25 25 + mac.Write([]byte(message)) 26 26 + signature := hex.EncodeToString(mac.Sum(nil)) 27 27 + req.Header.Set("X-Signature", signature) 28 28 + req.Header.Set("X-Timestamp", timestamp) 29 29 + return http.DefaultTransport.RoundTrip(req) 30 30 + } 31 31 + 32 32 + type SignedClient struct { 33 33 + Secret string 34 34 + Url *url.URL 35 35 + client *http.Client 36 36 + } 37 37 + 38 38 + func NewSignedClient(domain, secret string, dev bool) (*SignedClient, error) { 39 39 + client := &http.Client{ 40 40 + Timeout: 5 * time.Second, 41 41 + Transport: SignerTransport{ 42 42 + Secret: secret, 43 43 + }, 44 44 + } 45 45 + 46 46 + scheme := "https" 47 47 + if dev { 48 48 + scheme = "http" 49 49 + } 50 50 + url, err := url.Parse(fmt.Sprintf("%s://%s", scheme, domain)) 51 51 + if err != nil { 52 52 + return nil, err 53 53 + } 54 54 + 55 55 + signedClient := &SignedClient{ 56 56 + Secret: secret, 57 57 + client: client, 58 58 + Url: url, 59 59 + } 60 60 + 61 61 + return signedClient, nil 62 62 + } 63 63 + 64 64 + func (s *SignedClient) newRequest(method, endpoint string, body []byte) (*http.Request, error) { 65 65 + return http.NewRequest(method, s.Url.JoinPath(endpoint).String(), bytes.NewReader(body)) 66 66 + } 67 67 + 68 68 + func (s *SignedClient) Init(did string) (*http.Response, error) { 69 69 + const ( 70 70 + Method = "POST" 71 71 + Endpoint = "/init" 72 72 + ) 73 73 + 74 74 + body, _ := json.Marshal(map[string]any{ 75 75 + "did": did, 76 76 + }) 77 77 + 78 78 + req, err := s.newRequest(Method, Endpoint, body) 79 79 + if err != nil { 80 80 + return nil, err 81 81 + } 82 82 + 83 83 + return s.client.Do(req) 84 84 + } 85 85 + 86 86 + func (s *SignedClient) NewRepo(did, repoName, defaultBranch string) (*http.Response, error) { 87 87 + const ( 88 88 + Method = "PUT" 89 89 + Endpoint = "/repo/new" 90 90 + ) 91 91 + 92 92 + body, _ := json.Marshal(map[string]any{ 93 93 + "did": did, 94 94 + "name": repoName, 95 95 + "default_branch": defaultBranch, 96 96 + }) 97 97 + 98 98 + req, err := s.newRequest(Method, Endpoint, body) 99 99 + if err != nil { 100 100 + return nil, err 101 101 + } 102 102 + 103 103 + return s.client.Do(req) 104 104 + } 105 105 + 106 106 + func (s *SignedClient) ForkRepo(ownerDid, source, name string) (*http.Response, error) { 107 107 + const ( 108 108 + Method = "POST" 109 109 + Endpoint = "/repo/fork" 110 110 + ) 111 111 + 112 112 + body, _ := json.Marshal(map[string]any{ 113 113 + "did": ownerDid, 114 114 + "source": source, 115 115 + "name": name, 116 116 + }) 117 117 + 118 118 + req, err := s.newRequest(Method, Endpoint, body) 119 119 + if err != nil { 120 120 + return nil, err 121 121 + } 122 122 + 123 123 + return s.client.Do(req) 124 124 + } 125 125 + 126 126 + func (s *SignedClient) RemoveRepo(did, repoName string) (*http.Response, error) { 127 127 + const ( 128 128 + Method = "DELETE" 129 129 + Endpoint = "/repo" 130 130 + ) 131 131 + 132 132 + body, _ := json.Marshal(map[string]any{ 133 133 + "did": did, 134 134 + "name": repoName, 135 135 + }) 136 136 + 137 137 + req, err := s.newRequest(Method, Endpoint, body) 138 138 + if err != nil { 139 139 + return nil, err 140 140 + } 141 141 + 142 142 + return s.client.Do(req) 143 143 + } 144 144 + 145 145 + func (s *SignedClient) AddMember(did string) (*http.Response, error) { 146 146 + const ( 147 147 + Method = "PUT" 148 148 + Endpoint = "/member/add" 149 149 + ) 150 150 + 151 151 + body, _ := json.Marshal(map[string]any{ 152 152 + "did": did, 153 153 + }) 154 154 + 155 155 + req, err := s.newRequest(Method, Endpoint, body) 156 156 + if err != nil { 157 157 + return nil, err 158 158 + } 159 159 + 160 160 + return s.client.Do(req) 161 161 + } 162 162 + 163 163 + func (s *SignedClient) SetDefaultBranch(ownerDid, repoName, branch string) (*http.Response, error) { 164 164 + const ( 165 165 + Method = "PUT" 166 166 + ) 167 167 + endpoint := fmt.Sprintf("/%s/%s/branches/default", ownerDid, repoName) 168 168 + 169 169 + body, _ := json.Marshal(map[string]any{ 170 170 + "branch": branch, 171 171 + }) 172 172 + 173 173 + req, err := s.newRequest(Method, endpoint, body) 174 174 + if err != nil { 175 175 + return nil, err 176 176 + } 177 177 + 178 178 + return s.client.Do(req) 179 179 + } 180 180 + 181 181 + func (s *SignedClient) AddCollaborator(ownerDid, repoName, memberDid string) (*http.Response, error) { 182 182 + const ( 183 183 + Method = "POST" 184 184 + ) 185 185 + endpoint := fmt.Sprintf("/%s/%s/collaborator/add", ownerDid, repoName) 186 186 + 187 187 + body, _ := json.Marshal(map[string]any{ 188 188 + "did": memberDid, 189 189 + }) 190 190 + 191 191 + req, err := s.newRequest(Method, endpoint, body) 192 192 + if err != nil { 193 193 + return nil, err 194 194 + } 195 195 + 196 196 + return s.client.Do(req) 197 197 + } 198 198 + 199 199 + func (s *SignedClient) Merge( 200 200 + patch []byte, 201 201 + ownerDid, targetRepo, branch, commitMessage, commitBody, authorName, authorEmail string, 202 202 + ) (*http.Response, error) { 203 203 + const ( 204 204 + Method = "POST" 205 205 + ) 206 206 + endpoint := fmt.Sprintf("/%s/%s/merge", ownerDid, targetRepo) 207 207 + 208 208 + mr := types.MergeRequest{ 209 209 + Branch: branch, 210 210 + CommitMessage: commitMessage, 211 211 + CommitBody: commitBody, 212 212 + AuthorName: authorName, 213 213 + AuthorEmail: authorEmail, 214 214 + Patch: string(patch), 215 215 + } 216 216 + 217 217 + body, _ := json.Marshal(mr) 218 218 + 219 219 + req, err := s.newRequest(Method, endpoint, body) 220 220 + if err != nil { 221 221 + return nil, err 222 222 + } 223 223 + 224 224 + return s.client.Do(req) 225 225 + } 226 226 + 227 227 + func (s *SignedClient) MergeCheck(patch []byte, ownerDid, targetRepo, branch string) (*http.Response, error) { 228 228 + const ( 229 229 + Method = "POST" 230 230 + ) 231 231 + endpoint := fmt.Sprintf("/%s/%s/merge/check", ownerDid, targetRepo) 232 232 + 233 233 + body, _ := json.Marshal(map[string]any{ 234 234 + "patch": string(patch), 235 235 + "branch": branch, 236 236 + }) 237 237 + 238 238 + req, err := s.newRequest(Method, endpoint, body) 239 239 + if err != nil { 240 240 + return nil, err 241 241 + } 242 242 + 243 243 + return s.client.Do(req) 244 244 + } 245 245 + 246 246 + func (s *SignedClient) NewHiddenRef(ownerDid, targetRepo, forkBranch, remoteBranch string) (*http.Response, error) { 247 247 + const ( 248 248 + Method = "POST" 249 249 + ) 250 250 + endpoint := fmt.Sprintf("/%s/%s/hidden-ref/%s/%s", ownerDid, targetRepo, url.PathEscape(forkBranch), url.PathEscape(remoteBranch)) 251 251 + 252 252 + req, err := s.newRequest(Method, endpoint, nil) 253 253 + if err != nil { 254 254 + return nil, err 255 255 + } 256 256 + 257 257 + return s.client.Do(req) 258 258 + }

+142

knotclient/unsigned.go

··· 1 1 + package knotclient 2 2 + 3 3 + import ( 4 4 + "bytes" 5 5 + "encoding/json" 6 6 + "fmt" 7 7 + "io" 8 8 + "net/http" 9 9 + "net/url" 10 10 + "path" 11 11 + "strconv" 12 12 + 13 13 + "tangled.sh/tangled.sh/core/types" 14 14 + ) 15 15 + 16 16 + type UnsignedClient struct { 17 17 + Domain string 18 18 + Dev bool 19 19 + client *http.Client 20 20 + } 21 21 + 22 22 + func (u *UnsignedClient) scheme() string { 23 23 + if u.Dev { 24 24 + return "http" 25 25 + } 26 26 + 27 27 + return "https" 28 28 + } 29 29 + 30 30 + func (u *UnsignedClient) url() (*url.URL, error) { 31 31 + return url.Parse(fmt.Sprintf("%s://%s", u.scheme(), u.Domain)) 32 32 + } 33 33 + 34 34 + type KnotRequest interface { 35 35 + Method() string 36 36 + Path() string 37 37 + Query() url.Values 38 38 + Body() []byte 39 39 + } 40 40 + 41 41 + func do[T any](u *UnsignedClient, method, path string, query url.Values, body []byte) (*T, error) { 42 42 + // Create a copy of the base URL to avoid modifying the original 43 43 + base, err := u.url() 44 44 + if err != nil { 45 45 + return nil, fmt.Errorf("failed to parse URL: %w", err) 46 46 + } 47 47 + 48 48 + // add path 49 49 + base = base.JoinPath(path) 50 50 + 51 51 + // add query 52 52 + if query != nil { 53 53 + base.RawQuery = query.Encode() 54 54 + } 55 55 + 56 56 + // Create the request 57 57 + req, err := http.NewRequest(method, base.String(), bytes.NewReader(body)) 58 58 + if err != nil { 59 59 + return nil, err 60 60 + } 61 61 + 62 62 + resp, err := u.client.Do(req) 63 63 + if err != nil { 64 64 + return nil, err 65 65 + } 66 66 + defer resp.Body.Close() 67 67 + 68 68 + body, err = io.ReadAll(resp.Body) 69 69 + if err != nil { 70 70 + return nil, err 71 71 + } 72 72 + 73 73 + var result T 74 74 + err = json.Unmarshal(body, &result) 75 75 + if err != nil { 76 76 + return nil, err 77 77 + } 78 78 + 79 79 + return &result, nil 80 80 + } 81 81 + 82 82 + func (u *UnsignedClient) Index(ownerDid, repoName, ref string) (*types.RepoIndexResponse, error) { 83 83 + method := http.MethodGet 84 84 + endpoint := path.Join(ownerDid, repoName, "tree", ref) 85 85 + if ref == "" { 86 86 + endpoint = path.Join(ownerDid, repoName) 87 87 + } 88 88 + return do[types.RepoIndexResponse](u, method, endpoint, nil, nil) 89 89 + } 90 90 + 91 91 + func (u *UnsignedClient) Log(ownerDid, repoName, ref string, page int) (*types.RepoLogResponse, error) { 92 92 + method := http.MethodGet 93 93 + endpoint := fmt.Sprintf("/%s/%s/log/%s", ownerDid, repoName, url.PathEscape(ref)) 94 94 + 95 95 + query := url.Values{} 96 96 + query.Add("page", strconv.Itoa(page)) 97 97 + query.Add("per_page", strconv.Itoa(60)) 98 98 + 99 99 + return do[types.RepoLogResponse](u, method, endpoint, nil, nil) 100 100 + } 101 101 + 102 102 + func (u *UnsignedClient) Branches(ownerDid, repoName string) (*types.RepoBranchesResponse, error) { 103 103 + method := http.MethodGet 104 104 + endpoint := fmt.Sprintf("/%s/%s/branches", ownerDid, repoName) 105 105 + 106 106 + return do[types.RepoBranchesResponse](u, method, endpoint, nil, nil) 107 107 + } 108 108 + 109 109 + func (u *UnsignedClient) Tags(ownerDid, repoName string) (*types.RepoTagsResponse, error) { 110 110 + method := http.MethodGet 111 111 + endpoint := fmt.Sprintf("/%s/%s/tags", ownerDid, repoName) 112 112 + 113 113 + return do[types.RepoTagsResponse](u, method, endpoint, nil, nil) 114 114 + } 115 115 + 116 116 + func (u *UnsignedClient) Branch(ownerDid, repoName, branch string) (*types.RepoBranchResponse, error) { 117 117 + method := http.MethodGet 118 118 + endpoint := fmt.Sprintf("/%s/%s/branches/%s", ownerDid, repoName, url.PathEscape(branch)) 119 119 + 120 120 + return do[types.RepoBranchResponse](u, method, endpoint, nil, nil) 121 121 + } 122 122 + 123 123 + func (u *UnsignedClient) DefaultBranch(ownerDid, repoName string) (*types.RepoBranchResponse, error) { 124 124 + method := http.MethodGet 125 125 + endpoint := fmt.Sprintf("/%s/%s/branches/default", ownerDid, repoName) 126 126 + 127 127 + return do[types.RepoBranchResponse](u, method, endpoint, nil, nil) 128 128 + } 129 129 + 130 130 + func (u *UnsignedClient) Capabilities() (*types.Capabilities, error) { 131 131 + method := http.MethodGet 132 132 + endpoint := "capabilities" 133 133 + 134 134 + return do[types.Capabilities](u, method, endpoint, nil, nil) 135 135 + } 136 136 + 137 137 + func (u *UnsignedClient) Compare(ownerDid, repoName, rev1, rev2 string) (*types.RepoFormatPatchResponse, error) { 138 138 + method := http.MethodGet 139 139 + endpoint := fmt.Sprintf("/%s/%s/compare/%s/%s", ownerDid, repoName, url.PathEscape(rev1), url.PathEscape(rev2)) 140 140 + 141 141 + return do[types.RepoFormatPatchResponse](u, method, endpoint, nil, nil) 142 142 + }