···

       
234
       
234
       
 
       
			f, err := mw.repoResolver.Resolve(r)

     

       
235
       
235
       
 
       
			if err != nil {

     

       
236
       
236
       
 
       
				log.Println("failed to fully resolve repo", err)

     

       
237
       
237
       
-
       
				http.Error(w, "invalid repo url", http.StatusNotFound)

     

       
237
       
237
       
+
       
				mw.pages.ErrorKnot404(w)

     

       
238
       
238
       
 
       
				return

     

       
239
       
239
       
 
       
			}

     

       
240
       
240
       
 
       


     
···

       
283
       
283
       
 
       
			f, err := mw.repoResolver.Resolve(r)

     

       
284
       
284
       
 
       
			if err != nil {

     

       
285
       
285
       
 
       
				log.Println("failed to fully resolve repo", err)

     

       
286
       
286
       
-
       
				http.Error(w, "invalid repo url", http.StatusNotFound)

     

       
286
       
286
       
+
       
				mw.pages.ErrorKnot404(w)

     

       
287
       
287
       
 
       
				return

     

       
288
       
288
       
 
       
			}

     

       
289
       
289
       
 
       


     

···

       
1272
       
1272
       
 
       
	return p.execute("errors/404", w, nil)

     

       
1273
       
1273
       
 
       
}

     

       
1274
       
1274
       
 
       


     

       
1275
       
1275
       
+
       
func (p *Pages) ErrorKnot404(w io.Writer) error {

     

       
1276
       
1276
       
+
       
	return p.execute("errors/knot404", w, nil)

     

       
1277
       
1277
       
+
       
}

     

       
1278
       
1278
       
+
       


     

       
1275
       
1279
       
 
       
func (p *Pages) Error503(w io.Writer) error {

     

       
1276
       
1280
       
 
       
	return p.execute("errors/503", w, nil)

     

       
1277
       
1281
       
 
       
}

     

···

       
1
       
1
       
+
       
{{ define "title" }}404 · tangled{{ end }}

     

       
2
       
2
       
+
       


     

       
3
       
3
       
+
       
{{ define "content" }}

     

       
4
       
4
       
+
       
    <h1>404 &mdash; repository not found!</h1>

     

       
5
       
5
       
+
       
    <p>

     

       
6
       
6
       
+
       
        The repository you were looking for could not be found.

     

       
7
       
7
       
+
       
        The knot serving the repository may be unavailable.

     

       
8
       
8
       
+
       
    </p>

     

       
9
       
9
       
+
       
{{ end }}

     

···

       
125
       
125
       
 
       


     

       
126
       
126
       
 
       
	repolog, err := us.Log(f.OwnerDid(), f.Name, ref, page)

     

       
127
       
127
       
 
       
	if err != nil {

     

       
128
       
128
       
+
       
		rp.pages.Error503(w)

     

       
128
       
129
       
 
       
		log.Println("failed to reach knotserver", err)

     

       
129
       
130
       
 
       
		return

     

       
130
       
131
       
 
       
	}

     

       
131
       
132
       
 
       


     

       
132
       
133
       
 
       
	tagResult, err := us.Tags(f.OwnerDid(), f.Name)

     

       
133
       
134
       
 
       
	if err != nil {

     

       
135
       
135
       
+
       
		rp.pages.Error503(w)

     

       
134
       
136
       
 
       
		log.Println("failed to reach knotserver", err)

     

       
135
       
137
       
 
       
		return

     

       
136
       
138
       
 
       
	}

     
···

       
146
       
148
       
 
       


     

       
147
       
149
       
 
       
	branchResult, err := us.Branches(f.OwnerDid(), f.Name)

     

       
148
       
150
       
 
       
	if err != nil {

     

       
151
       
151
       
+
       
		rp.pages.Error503(w)

     

       
149
       
152
       
 
       
		log.Println("failed to reach knotserver", err)

     

       
150
       
153
       
 
       
		return

     

       
151
       
154
       
 
       
	}

     
···

       
312
       
315
       
 
       


     

       
313
       
316
       
 
       
	resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/commit/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref))

     

       
314
       
317
       
 
       
	if err != nil {

     

       
318
       
318
       
+
       
		rp.pages.Error503(w)

     

       
315
       
319
       
 
       
		log.Println("failed to reach knotserver", err)

     

       
316
       
320
       
 
       
		return

     

       
317
       
321
       
 
       
	}

     
···

       
382
       
386
       
 
       


     

       
383
       
387
       
 
       
	resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/tree/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, treePath))

     

       
384
       
388
       
 
       
	if err != nil {

     

       
389
       
389
       
+
       
		rp.pages.Error503(w)

     

       
385
       
390
       
 
       
		log.Println("failed to reach knotserver", err)

     

       
386
       
391
       
 
       
		return

     

       
387
       
392
       
 
       
	}

     
···

       
451
       
456
       
 
       


     

       
452
       
457
       
 
       
	result, err := us.Tags(f.OwnerDid(), f.Name)

     

       
453
       
458
       
 
       
	if err != nil {

     

       
459
       
459
       
+
       
		rp.pages.Error503(w)

     

       
454
       
460
       
 
       
		log.Println("failed to reach knotserver", err)

     

       
455
       
461
       
 
       
		return

     

       
456
       
462
       
 
       
	}

     
···

       
508
       
514
       
 
       


     

       
509
       
515
       
 
       
	result, err := us.Branches(f.OwnerDid(), f.Name)

     

       
510
       
516
       
 
       
	if err != nil {

     

       
517
       
517
       
+
       
		rp.pages.Error503(w)

     

       
511
       
518
       
 
       
		log.Println("failed to reach knotserver", err)

     

       
512
       
519
       
 
       
		return

     

       
513
       
520
       
 
       
	}

     
···

       
537
       
544
       
 
       
	}

     

       
538
       
545
       
 
       
	resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/blob/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, filePath))

     

       
539
       
546
       
 
       
	if err != nil {

     

       
547
       
547
       
+
       
		rp.pages.Error503(w)

     

       
540
       
548
       
 
       
		log.Println("failed to reach knotserver", err)

     

       
541
       
549
       
 
       
		return

     

       
542
       
550
       
 
       
	}

     
···

       
1260
       
1268
       
 
       


     

       
1261
       
1269
       
 
       
	result, err := us.Branches(f.OwnerDid(), f.Name)

     

       
1262
       
1270
       
 
       
	if err != nil {

     

       
1271
       
1271
       
+
       
		rp.pages.Error503(w)

     

       
1263
       
1272
       
 
       
		log.Println("failed to reach knotserver", err)

     

       
1264
       
1273
       
 
       
		return

     

       
1265
       
1274
       
 
       
	}