images.go 33.5 KB
Newer Older
1
2
3
package server

import (
4
	"bufio"
5
	"bytes"
6
	"context"
7
8
9
10
	"crypto/sha256"
	"encoding/json"
	"errors"
	"fmt"
11
	"html/template"
12
13
14
15
16
	"io"
	"log"
	"net/http"
	"os"
	"path/filepath"
Michael Yang's avatar
Michael Yang committed
17
	"reflect"
18
19
20
21
	"strconv"
	"strings"

	"github.com/jmorganca/ollama/api"
22
	"github.com/jmorganca/ollama/llm"
23
	"github.com/jmorganca/ollama/parser"
24
	"github.com/jmorganca/ollama/vector"
25
26
)

27
28
const MaxRetries = 3

29
30
31
32
type RegistryOptions struct {
	Insecure bool
	Username string
	Password string
Patrick Devine's avatar
Patrick Devine committed
33
	Token    string
34
35
}

36
type Model struct {
37
38
39
40
41
42
43
44
	Name         string `json:"name"`
	ModelPath    string
	AdapterPaths []string
	Template     string
	System       string
	Digest       string
	Options      map[string]interface{}
	Embeddings   []vector.Embedding
45
46
}

Bruce MacDonald's avatar
Bruce MacDonald committed
47
func (m *Model) Prompt(request api.GenerateRequest, embedding string) (string, error) {
48
49
50
51
52
53
	t := m.Template
	if request.Template != "" {
		t = request.Template
	}

	tmpl, err := template.New("").Parse(t)
54
55
56
57
58
	if err != nil {
		return "", err
	}

	var vars struct {
Michael Yang's avatar
Michael Yang committed
59
		First  bool
60
61
		System string
		Prompt string
62
		Embed  string
63
64
65

		// deprecated: versions <= 0.0.7 used this to omit the system prompt
		Context []int
66
67
	}

Michael Yang's avatar
Michael Yang committed
68
	vars.First = len(request.Context) == 0
69
70
	vars.System = m.System
	vars.Prompt = request.Prompt
Michael Yang's avatar
Michael Yang committed
71
	vars.Context = request.Context
Bruce MacDonald's avatar
Bruce MacDonald committed
72
	vars.Embed = embedding
73

74
75
76
77
	if request.System != "" {
		vars.System = request.System
	}

78
79
80
81
82
83
84
85
	var sb strings.Builder
	if err := tmpl.Execute(&sb, vars); err != nil {
		return "", err
	}

	return sb.String(), nil
}

86
87
88
89
90
91
92
93
94
95
96
97
98
type ManifestV2 struct {
	SchemaVersion int      `json:"schemaVersion"`
	MediaType     string   `json:"mediaType"`
	Config        Layer    `json:"config"`
	Layers        []*Layer `json:"layers"`
}

type Layer struct {
	MediaType string `json:"mediaType"`
	Digest    string `json:"digest"`
	Size      int    `json:"size"`
}

Michael Yang's avatar
Michael Yang committed
99
type LayerReader struct {
100
	Layer
Michael Yang's avatar
Michael Yang committed
101
	io.Reader
102
103
104
}

type ConfigV2 struct {
105
106
107
108
109
110
	ModelFamily llm.ModelFamily `json:"model_family"`
	ModelType   llm.ModelType   `json:"model_type"`
	FileType    llm.FileType    `json:"file_type"`
	RootFS      RootFS          `json:"rootfs"`

	// required by spec
111
112
113
114
115
116
117
118
119
	Architecture string `json:"architecture"`
	OS           string `json:"os"`
}

type RootFS struct {
	Type    string   `json:"type"`
	DiffIDs []string `json:"diff_ids"`
}

Patrick Devine's avatar
Patrick Devine committed
120
121
122
123
124
125
126
127
128
func (m *ManifestV2) GetTotalSize() int {
	var total int
	for _, layer := range m.Layers {
		total += layer.Size
	}
	total += m.Config.Size
	return total
}

Patrick Devine's avatar
Patrick Devine committed
129
130
func GetManifest(mp ModelPath) (*ManifestV2, error) {
	fp, err := mp.GetManifestPath(false)
131
132
133
	if err != nil {
		return nil, err
	}
134

135
136
	if _, err = os.Stat(fp); err != nil {
		return nil, err
137
138
139
140
	}

	var manifest *ManifestV2

141
	bts, err := os.ReadFile(fp)
142
143
144
145
	if err != nil {
		return nil, fmt.Errorf("couldn't open file '%s'", fp)
	}

146
	if err := json.Unmarshal(bts, &manifest); err != nil {
147
148
149
150
151
152
153
		return nil, err
	}

	return manifest, nil
}

func GetModel(name string) (*Model, error) {
Patrick Devine's avatar
Patrick Devine committed
154
155
156
	mp := ParseModelPath(name)

	manifest, err := GetManifest(mp)
157
158
159
160
161
	if err != nil {
		return nil, err
	}

	model := &Model{
162
		Name:   mp.GetFullTagname(),
Jeffrey Morgan's avatar
Jeffrey Morgan committed
163
		Digest: manifest.Config.Digest,
164
165
166
	}

	for _, layer := range manifest.Layers {
Patrick Devine's avatar
Patrick Devine committed
167
		filename, err := GetBlobsPath(layer.Digest)
168
169
170
171
		if err != nil {
			return nil, err
		}

172
173
174
		switch layer.MediaType {
		case "application/vnd.ollama.image.model":
			model.ModelPath = filename
175
176
177
178
179
180
181
182
183
184
		case "application/vnd.ollama.image.embed":
			file, err := os.Open(filename)
			if err != nil {
				return nil, fmt.Errorf("failed to open file: %s", filename)
			}
			defer file.Close()

			if err = json.NewDecoder(file).Decode(&model.Embeddings); err != nil {
				return nil, err
			}
185
186
		case "application/vnd.ollama.image.adapter":
			model.AdapterPaths = append(model.AdapterPaths, filename)
187
188
189
190
191
192
193
194
195
		case "application/vnd.ollama.image.template":
			bts, err := os.ReadFile(filename)
			if err != nil {
				return nil, err
			}

			model.Template = string(bts)
		case "application/vnd.ollama.image.system":
			bts, err := os.ReadFile(filename)
196
197
198
			if err != nil {
				return nil, err
			}
199
200

			model.System = string(bts)
201
202
203
204
205
206
207
		case "application/vnd.ollama.image.prompt":
			bts, err := os.ReadFile(filename)
			if err != nil {
				return nil, err
			}

			model.Template = string(bts)
208
		case "application/vnd.ollama.image.params":
Michael Yang's avatar
Michael Yang committed
209
210
211
212
213
			params, err := os.Open(filename)
			if err != nil {
				return nil, err
			}
			defer params.Close()
214

215
			// parse model options parameters into a map so that we can see which fields have been specified explicitly
216
			if err = json.NewDecoder(params).Decode(&model.Options); err != nil {
217
218
				return nil, err
			}
219
220
221
222
223
224
		}
	}

	return model, nil
}

225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
func filenameWithPath(path, f string) (string, error) {
	// if filePath starts with ~/, replace it with the user's home directory.
	if strings.HasPrefix(f, "~/") {
		parts := strings.Split(f, "/")
		home, err := os.UserHomeDir()
		if err != nil {
			return "", fmt.Errorf("failed to open file: %v", err)
		}

		f = filepath.Join(home, filepath.Join(parts[1:]...))
	}

	// if filePath is not an absolute path, make it relative to the modelfile path
	if !filepath.IsAbs(f) {
		f = filepath.Join(filepath.Dir(path), f)
	}

	return f, nil
}

245
func CreateModel(ctx context.Context, name string, path string, fn func(resp api.ProgressResponse)) error {
246
247
	mf, err := os.Open(path)
	if err != nil {
248
		fn(api.ProgressResponse{Status: fmt.Sprintf("couldn't open modelfile '%s'", path)})
249
		return fmt.Errorf("failed to open file: %w", err)
250
	}
251
	defer mf.Close()
252

253
	fn(api.ProgressResponse{Status: "parsing modelfile"})
254
255
256
257
258
	commands, err := parser.Parse(mf)
	if err != nil {
		return err
	}

259
260
261
262
263
	config := ConfigV2{
		Architecture: "amd64",
		OS:           "linux",
	}

Michael Yang's avatar
Michael Yang committed
264
	var layers []*LayerReader
265
	params := make(map[string][]string)
266
	embed := EmbeddingParams{fn: fn, opts: api.DefaultOptions()}
267
	for _, c := range commands {
268
		log.Printf("[%s] - %s\n", c.Name, c.Args)
269
270
		switch c.Name {
		case "model":
271
			fn(api.ProgressResponse{Status: "looking for model"})
272
			embed.model = c.Args
273
			mf, err := GetManifest(ParseModelPath(c.Args))
274
			if err != nil {
275
276
277
				modelFile, err := filenameWithPath(path, c.Args)
				if err != nil {
					return err
278
				}
279
				if _, err := os.Stat(modelFile); err != nil {
280
281
282
					// the model file does not exist, try pulling it
					if errors.Is(err, os.ErrNotExist) {
						fn(api.ProgressResponse{Status: "pulling model file"})
283
						if err := PullModel(ctx, c.Args, &RegistryOptions{}, fn); err != nil {
284
285
							return err
						}
286
						mf, err = GetManifest(ParseModelPath(c.Args))
287
288
289
290
291
292
293
294
295
						if err != nil {
							return fmt.Errorf("failed to open file after pull: %v", err)
						}
					} else {
						return err
					}
				} else {
					// create a model from this specified file
					fn(api.ProgressResponse{Status: "creating model layer"})
296
					file, err := os.Open(modelFile)
297
298
299
300
301
					if err != nil {
						return fmt.Errorf("failed to open file: %v", err)
					}
					defer file.Close()

302
303
304
305
306
307
308
309
310
311
312
313
					ggml, err := llm.DecodeGGML(file, llm.ModelFamilyLlama)
					if err != nil {
						return err
					}

					config.ModelFamily = ggml.ModelFamily
					config.ModelType = ggml.ModelType
					config.FileType = ggml.FileType

					// reset the file
					file.Seek(0, io.SeekStart)

314
315
316
317
318
319
					l, err := CreateLayer(file)
					if err != nil {
						return fmt.Errorf("failed to create layer: %v", err)
					}
					l.MediaType = "application/vnd.ollama.image.model"
					layers = append(layers, l)
320
				}
321
			}
322

323
			if mf != nil {
324
325
326
327
328
329
330
331
332
				log.Printf("manifest = %#v", mf)
				for _, l := range mf.Layers {
					newLayer, err := GetLayerWithBufferFromLayer(l)
					if err != nil {
						return err
					}
					layers = append(layers, newLayer)
				}
			}
333
334
		case "embed":
			embedFilePath, err := filenameWithPath(path, c.Args)
Michael Yang's avatar
Michael Yang committed
335
336
337
			if err != nil {
				return err
			}
338
			embed.files = append(embed.files, embedFilePath)
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
		case "adapter":
			fn(api.ProgressResponse{Status: fmt.Sprintf("creating model %s layer", c.Name)})

			fp := c.Args
			if strings.HasPrefix(fp, "~/") {
				parts := strings.Split(fp, "/")
				home, err := os.UserHomeDir()
				if err != nil {
					return fmt.Errorf("failed to open file: %v", err)
				}

				fp = filepath.Join(home, filepath.Join(parts[1:]...))
			}

			// If filePath is not an absolute path, make it relative to the modelfile path
			if !filepath.IsAbs(fp) {
				fp = filepath.Join(filepath.Dir(path), fp)
			}

			// create a model from this specified file
			fn(api.ProgressResponse{Status: "creating model layer"})

			file, err := os.Open(fp)
			if err != nil {
				return fmt.Errorf("failed to open file: %v", err)
			}
			defer file.Close()

			l, err := CreateLayer(file)
			if err != nil {
				return fmt.Errorf("failed to create layer: %v", err)
			}
			l.MediaType = "application/vnd.ollama.image.adapter"
			layers = append(layers, l)
Bruce MacDonald's avatar
Bruce MacDonald committed
373
374
375
376
377
378
379
380
381
382
383
384
		case "license":
			fn(api.ProgressResponse{Status: fmt.Sprintf("creating model %s layer", c.Name)})
			mediaType := fmt.Sprintf("application/vnd.ollama.image.%s", c.Name)

			layer, err := CreateLayer(strings.NewReader(c.Args))
			if err != nil {
				return err
			}

			layer.MediaType = mediaType
			layers = append(layers, layer)
		case "template", "system", "prompt":
385
			fn(api.ProgressResponse{Status: fmt.Sprintf("creating model %s layer", c.Name)})
386
			// remove the layer if one exists
387
388
			mediaType := fmt.Sprintf("application/vnd.ollama.image.%s", c.Name)
			layers = removeLayerFromLayers(layers, mediaType)
389

390
			layer, err := CreateLayer(strings.NewReader(c.Args))
391
			if err != nil {
392
				return err
393
			}
394
395
396

			layer.MediaType = mediaType
			layers = append(layers, layer)
397
		default:
398
399
			// runtime parameters, build a list of args for each parameter to allow multiple values to be specified (ex: multiple stop tokens)
			params[c.Name] = append(params[c.Name], c.Args)
400
401
402
403
		}
	}

	// Create a single layer for the parameters
Michael Yang's avatar
Michael Yang committed
404
	if len(params) > 0 {
405
		fn(api.ProgressResponse{Status: "creating parameter layer"})
406
		layers = removeLayerFromLayers(layers, "application/vnd.ollama.image.params")
407
		formattedParams, err := formatParams(params)
408
409
410
		if err != nil {
			return fmt.Errorf("couldn't create params json: %v", err)
		}
411
412
413
414
415
416
417

		bts, err := json.Marshal(formattedParams)
		if err != nil {
			return err
		}

		l, err := CreateLayer(bytes.NewReader(bts))
418
419
420
421
422
		if err != nil {
			return fmt.Errorf("failed to create layer: %v", err)
		}
		l.MediaType = "application/vnd.ollama.image.params"
		layers = append(layers, l)
423
424
425
426

		// apply these parameters to the embedding options, in case embeddings need to be generated using this model
		embed.opts = api.DefaultOptions()
		embed.opts.FromMap(formattedParams)
427
428
	}

429
430
431
432
433
434
435
	// generate the embedding layers
	embeddingLayers, err := embeddingLayers(embed)
	if err != nil {
		return err
	}
	layers = append(layers, embeddingLayers...)

436
437
438
439
440
441
442
443
444
445
446
	digests, err := getLayerDigests(layers)
	if err != nil {
		return err
	}

	var manifestLayers []*Layer
	for _, l := range layers {
		manifestLayers = append(manifestLayers, &l.Layer)
	}

	// Create a layer for the config object
447
	fn(api.ProgressResponse{Status: "creating config layer"})
448
	cfg, err := createConfigLayer(config, digests)
449
450
451
452
453
454
455
456
457
458
459
	if err != nil {
		return err
	}
	layers = append(layers, cfg)

	err = SaveLayers(layers, fn, false)
	if err != nil {
		return err
	}

	// Create the manifest
460
	fn(api.ProgressResponse{Status: "writing manifest"})
461
462
463
464
465
	err = CreateManifest(name, cfg, manifestLayers)
	if err != nil {
		return err
	}

466
	fn(api.ProgressResponse{Status: "success"})
467
468
469
	return nil
}

470
471
472
473
474
475
476
477
478
479
480
type EmbeddingParams struct {
	model string
	opts  api.Options
	files []string // paths to files to embed
	fn    func(resp api.ProgressResponse)
}

// embeddingLayers loads the associated LLM and generates the embeddings to be stored from an input file
func embeddingLayers(e EmbeddingParams) ([]*LayerReader, error) {
	layers := []*LayerReader{}
	if len(e.files) > 0 {
481
482
483
484
485
486
487
488
489
490
491
		if _, err := os.Stat(e.model); err != nil {
			if os.IsNotExist(err) {
				// this is a model name rather than the file
				model, err := GetModel(e.model)
				if err != nil {
					return nil, fmt.Errorf("failed to get model to generate embeddings: %v", err)
				}
				e.model = model.ModelPath
			} else {
				return nil, fmt.Errorf("failed to get model file to generate embeddings: %v", err)
			}
492
493
494
		}

		e.opts.EmbeddingOnly = true
495
		llmModel, err := llm.New(e.model, []string{}, e.opts)
496
497
498
		if err != nil {
			return nil, fmt.Errorf("load model to generate embeddings: %v", err)
		}
Bruce MacDonald's avatar
Bruce MacDonald committed
499
		defer func() {
500
501
			if llmModel != nil {
				llmModel.Close()
Bruce MacDonald's avatar
Bruce MacDonald committed
502
503
			}
		}()
504

505
506
507
508
509
510
		// this will be used to check if we already have embeddings for a file
		modelDigest, err := modelDigest(e.model)
		if err != nil {
			return nil, fmt.Errorf("model digest: %w", err)
		}

Bruce MacDonald's avatar
Bruce MacDonald committed
511
512
513
		addedFiles := make(map[string]bool) // keep track of files that have already been added
		for _, filePattern := range e.files {
			matchingFiles, err := filepath.Glob(filePattern)
514
			if err != nil {
Bruce MacDonald's avatar
Bruce MacDonald committed
515
				return nil, fmt.Errorf("could not find files with pattern %s: %w", filePattern, err)
516
517
			}

Bruce MacDonald's avatar
Bruce MacDonald committed
518
519
			for _, filePath := range matchingFiles {
				if addedFiles[filePath] {
520
521
					continue
				}
Bruce MacDonald's avatar
Bruce MacDonald committed
522
				addedFiles[filePath] = true
Bruce MacDonald's avatar
Bruce MacDonald committed
523
				// check if we already have embeddings for this file path
524
				layerIdentifier := fmt.Sprintf("%s:%s", filePath, modelDigest)
Bruce MacDonald's avatar
Bruce MacDonald committed
525
526
527
528
529
530
				digest, _ := GetSHA256Digest(strings.NewReader(layerIdentifier))
				existing, err := existingFileEmbeddings(digest)
				if err != nil {
					return nil, fmt.Errorf("failed to check existing embeddings for file %s: %v", filePath, err)
				}

Bruce MacDonald's avatar
Bruce MacDonald committed
531
532
				// TODO: check file type
				f, err := os.Open(filePath)
533
				if err != nil {
Bruce MacDonald's avatar
Bruce MacDonald committed
534
					return nil, fmt.Errorf("could not open embed file: %w", err)
535
				}
Bruce MacDonald's avatar
Bruce MacDonald committed
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
				scanner := bufio.NewScanner(f)
				scanner.Split(bufio.ScanLines)

				data := []string{}
				for scanner.Scan() {
					data = append(data, scanner.Text())
				}
				f.Close()

				// the digest of the file is set here so that the client knows a new operation is in progress
				fileDigest, _ := GetSHA256Digest(bytes.NewReader([]byte(filePath)))

				embeddings := []vector.Embedding{}
				for i, d := range data {
					if strings.TrimSpace(d) == "" {
						continue
					}
					e.fn(api.ProgressResponse{
						Status:    fmt.Sprintf("creating embeddings for file %s", filePath),
						Digest:    fileDigest,
						Total:     len(data) - 1,
						Completed: i,
					})
Bruce MacDonald's avatar
Bruce MacDonald committed
559
560
561
562
563
					if len(existing[d]) > 0 {
						// already have an embedding for this line
						embeddings = append(embeddings, vector.Embedding{Data: d, Vector: existing[d]})
						continue
					}
564
					embed, err := llmModel.Embedding(d)
Bruce MacDonald's avatar
Bruce MacDonald committed
565
					if err != nil {
566
567
						log.Printf("failed to generate embedding for '%s' line %d: %v", filePath, i+1, err)
						continue
Bruce MacDonald's avatar
Bruce MacDonald committed
568
569
					}
					embeddings = append(embeddings, vector.Embedding{Data: d, Vector: embed})
570
571
				}

Bruce MacDonald's avatar
Bruce MacDonald committed
572
573
574
575
576
				b, err := json.Marshal(embeddings)
				if err != nil {
					return nil, fmt.Errorf("failed to encode embeddings: %w", err)
				}
				r := bytes.NewReader(b)
577

Bruce MacDonald's avatar
Bruce MacDonald committed
578
579
580
581
				layer := &LayerReader{
					Layer: Layer{
						MediaType: "application/vnd.ollama.image.embed",
						Digest:    digest,
Bruce MacDonald's avatar
Bruce MacDonald committed
582
						Size:      r.Len(),
Bruce MacDonald's avatar
Bruce MacDonald committed
583
584
585
					},
					Reader: r,
				}
586

Bruce MacDonald's avatar
Bruce MacDonald committed
587
588
				layers = append(layers, layer)
			}
589
590
591
592
593
		}
	}
	return layers, nil
}

594
595
596
597
598
599
600
601
602
603
604
func modelDigest(modelPath string) (string, error) {
	modelFile, err := os.Open(modelPath)
	if err != nil {
		return "", fmt.Errorf("could not open model blob: %w", err)
	}
	defer modelFile.Close()

	digest, _ := GetSHA256Digest(modelFile)
	return digest, nil
}

Bruce MacDonald's avatar
Bruce MacDonald committed
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
// existingFileEmbeddings checks if we already have embeddings for a file and loads them into a look-up map
func existingFileEmbeddings(digest string) (map[string][]float64, error) {
	path, err := GetBlobsPath(digest)
	if err != nil {
		return nil, fmt.Errorf("embeddings blobs path: %w", err)
	}
	existingFileEmbeddings := make(map[string][]float64)
	if _, err := os.Stat(path); err == nil {
		// already have some embeddings for this file, load embeddings previously generated
		file, err := os.Open(path)
		if err != nil {
			return nil, fmt.Errorf("failed to open existing embedding file: %s", err)
		}
		defer file.Close()

		existing := []vector.Embedding{}
		if err = json.NewDecoder(file).Decode(&existing); err != nil {
			return nil, err
		}
		for _, e := range existing {
			existingFileEmbeddings[e.Data] = e.Vector
		}
	}
	return existingFileEmbeddings, nil
}

Michael Yang's avatar
Michael Yang committed
631
func removeLayerFromLayers(layers []*LayerReader, mediaType string) []*LayerReader {
632
633
634
635
636
637
638
639
640
641
	j := 0
	for _, l := range layers {
		if l.MediaType != mediaType {
			layers[j] = l
			j++
		}
	}
	return layers[:j]
}

642
func SaveLayers(layers []*LayerReader, fn func(resp api.ProgressResponse), force bool) error {
643
644
	// Write each of the layers to disk
	for _, layer := range layers {
Patrick Devine's avatar
Patrick Devine committed
645
		fp, err := GetBlobsPath(layer.Digest)
646
647
648
		if err != nil {
			return err
		}
649
650

		_, err = os.Stat(fp)
Bruce MacDonald's avatar
Bruce MacDonald committed
651
652
		// note: embed layers are always written since their digest doesnt indicate anything about the contents
		if os.IsNotExist(err) || force || layer.MediaType == "application/vnd.ollama.image.embed" {
653
654
			fn(api.ProgressResponse{Status: fmt.Sprintf("writing layer %s", layer.Digest)})

655
656
657
658
659
660
661
			out, err := os.Create(fp)
			if err != nil {
				log.Printf("couldn't create %s", fp)
				return err
			}
			defer out.Close()

Michael Yang's avatar
Michael Yang committed
662
			if _, err = io.Copy(out, layer.Reader); err != nil {
663
664
				return err
			}
Michael Yang's avatar
Michael Yang committed
665

666
		} else {
667
			fn(api.ProgressResponse{Status: fmt.Sprintf("using already created layer %s", layer.Digest)})
668
669
670
671
672
673
		}
	}

	return nil
}

Michael Yang's avatar
Michael Yang committed
674
func CreateManifest(name string, cfg *LayerReader, layers []*Layer) error {
Patrick Devine's avatar
Patrick Devine committed
675
676
	mp := ParseModelPath(name)

677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
	manifest := ManifestV2{
		SchemaVersion: 2,
		MediaType:     "application/vnd.docker.distribution.manifest.v2+json",
		Config: Layer{
			MediaType: cfg.MediaType,
			Size:      cfg.Size,
			Digest:    cfg.Digest,
		},
		Layers: layers,
	}

	manifestJSON, err := json.Marshal(manifest)
	if err != nil {
		return err
	}

Patrick Devine's avatar
Patrick Devine committed
693
	fp, err := mp.GetManifestPath(true)
694
695
696
	if err != nil {
		return err
	}
697
	return os.WriteFile(fp, manifestJSON, 0o644)
698
699
}

Michael Yang's avatar
Michael Yang committed
700
func GetLayerWithBufferFromLayer(layer *Layer) (*LayerReader, error) {
Patrick Devine's avatar
Patrick Devine committed
701
	fp, err := GetBlobsPath(layer.Digest)
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
	if err != nil {
		return nil, err
	}

	file, err := os.Open(fp)
	if err != nil {
		return nil, fmt.Errorf("could not open blob: %w", err)
	}
	defer file.Close()

	newLayer, err := CreateLayer(file)
	if err != nil {
		return nil, err
	}
	newLayer.MediaType = layer.MediaType
	return newLayer, nil
}

720
721
// formatParams converts specified parameter options to their correct types
func formatParams(params map[string][]string) (map[string]interface{}, error) {
722
723
724
	opts := api.Options{}
	valueOpts := reflect.ValueOf(&opts).Elem() // names of the fields in the options struct
	typeOpts := reflect.TypeOf(opts)           // types of the fields in the options struct
Michael Yang's avatar
Michael Yang committed
725

726
	// build map of json struct tags to their types
Michael Yang's avatar
Michael Yang committed
727
728
729
730
731
732
733
734
	jsonOpts := make(map[string]reflect.StructField)
	for _, field := range reflect.VisibleFields(typeOpts) {
		jsonTag := strings.Split(field.Tag.Get("json"), ",")[0]
		if jsonTag != "" {
			jsonOpts[jsonTag] = field
		}
	}

735
	out := make(map[string]interface{})
Michael Yang's avatar
Michael Yang committed
736
	// iterate params and set values based on json struct tags
737
	for key, vals := range params {
Michael Yang's avatar
Michael Yang committed
738
739
740
741
742
		if opt, ok := jsonOpts[key]; ok {
			field := valueOpts.FieldByName(opt.Name)
			if field.IsValid() && field.CanSet() {
				switch field.Kind() {
				case reflect.Float32:
743
					floatVal, err := strconv.ParseFloat(vals[0], 32)
Michael Yang's avatar
Michael Yang committed
744
					if err != nil {
745
						return nil, fmt.Errorf("invalid float value %s", vals)
Michael Yang's avatar
Michael Yang committed
746
747
					}

748
					out[key] = floatVal
Michael Yang's avatar
Michael Yang committed
749
				case reflect.Int:
750
					intVal, err := strconv.ParseInt(vals[0], 10, 0)
Michael Yang's avatar
Michael Yang committed
751
					if err != nil {
752
						return nil, fmt.Errorf("invalid int value %s", vals)
Michael Yang's avatar
Michael Yang committed
753
754
					}

755
					out[key] = intVal
Michael Yang's avatar
Michael Yang committed
756
				case reflect.Bool:
757
					boolVal, err := strconv.ParseBool(vals[0])
Michael Yang's avatar
Michael Yang committed
758
					if err != nil {
759
						return nil, fmt.Errorf("invalid bool value %s", vals)
Michael Yang's avatar
Michael Yang committed
760
761
					}

762
					out[key] = boolVal
Michael Yang's avatar
Michael Yang committed
763
				case reflect.String:
764
					out[key] = vals[0]
765
				case reflect.Slice:
766
767
					// TODO: only string slices are supported right now
					out[key] = vals
Michael Yang's avatar
Michael Yang committed
768
769
770
771
772
773
774
				default:
					return nil, fmt.Errorf("unknown type %s for %s", field.Kind(), key)
				}
			}
		}
	}

775
	return out, nil
776
777
}

Michael Yang's avatar
Michael Yang committed
778
func getLayerDigests(layers []*LayerReader) ([]string, error) {
779
780
781
782
783
784
785
786
787
788
789
	var digests []string
	for _, l := range layers {
		if l.Digest == "" {
			return nil, fmt.Errorf("layer is missing a digest")
		}
		digests = append(digests, l.Digest)
	}
	return digests, nil
}

// CreateLayer creates a Layer object from a given file
Michael Yang's avatar
Michael Yang committed
790
791
func CreateLayer(f io.ReadSeeker) (*LayerReader, error) {
	digest, size := GetSHA256Digest(f)
792
	f.Seek(0, io.SeekStart)
793

Michael Yang's avatar
Michael Yang committed
794
	layer := &LayerReader{
795
796
797
798
799
		Layer: Layer{
			MediaType: "application/vnd.docker.image.rootfs.diff.tar",
			Digest:    digest,
			Size:      size,
		},
Michael Yang's avatar
Michael Yang committed
800
		Reader: f,
801
802
803
804
805
	}

	return layer, nil
}

Patrick Devine's avatar
Patrick Devine committed
806
807
808
809
810
811
812
813
814
815
816
func CopyModel(src, dest string) error {
	srcPath, err := ParseModelPath(src).GetManifestPath(false)
	if err != nil {
		return err
	}
	destPath, err := ParseModelPath(dest).GetManifestPath(true)
	if err != nil {
		return err
	}

	// copy the file
Michael Yang's avatar
Michael Yang committed
817
	input, err := os.ReadFile(srcPath)
Patrick Devine's avatar
Patrick Devine committed
818
819
820
821
822
	if err != nil {
		fmt.Println("Error reading file:", err)
		return err
	}

Michael Yang's avatar
Michael Yang committed
823
	err = os.WriteFile(destPath, input, 0o644)
Patrick Devine's avatar
Patrick Devine committed
824
825
826
827
828
829
830
831
	if err != nil {
		fmt.Println("Error reading file:", err)
		return err
	}

	return nil
}

832
func DeleteModel(name string) error {
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
	mp := ParseModelPath(name)

	manifest, err := GetManifest(mp)
	if err != nil {
		return err
	}
	deleteMap := make(map[string]bool)
	for _, layer := range manifest.Layers {
		deleteMap[layer.Digest] = true
	}
	deleteMap[manifest.Config.Digest] = true

	fp, err := GetManifestPath()
	if err != nil {
		return err
	}
	err = filepath.Walk(fp, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if !info.IsDir() {
			path := path[len(fp)+1:]
			slashIndex := strings.LastIndex(path, "/")
			if slashIndex == -1 {
				return nil
			}
			tag := path[:slashIndex] + ":" + path[slashIndex+1:]
			fmp := ParseModelPath(tag)

			// skip the manifest we're trying to delete
			if mp.GetFullTagname() == fmp.GetFullTagname() {
				return nil
			}

			// save (i.e. delete from the deleteMap) any files used in other manifests
			manifest, err := GetManifest(fmp)
			if err != nil {
				log.Printf("skipping file: %s", fp)
				return nil
			}
			for _, layer := range manifest.Layers {
				delete(deleteMap, layer.Digest)
			}
			delete(deleteMap, manifest.Config.Digest)
		}
		return nil
	})
Michael Yang's avatar
Michael Yang committed
880
881
882
	if err != nil {
		return err
	}
883
884
885
886

	// only delete the files which are still in the deleteMap
	for k, v := range deleteMap {
		if v {
887
			fp, err := GetBlobsPath(k)
888
			if err != nil {
889
890
891
892
893
				log.Printf("couldn't get file path for '%s': %v", k, err)
				continue
			}
			if err := os.Remove(fp); err != nil {
				log.Printf("couldn't remove file '%s': %v", fp, err)
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
				continue
			}
		}
	}

	fp, err = mp.GetManifestPath(false)
	if err != nil {
		return err
	}
	err = os.Remove(fp)
	if err != nil {
		log.Printf("couldn't remove manifest file '%s': %v", fp, err)
		return err
	}

	return nil
}

912
func PushModel(ctx context.Context, name string, regOpts *RegistryOptions, fn func(api.ProgressResponse)) error {
Patrick Devine's avatar
Patrick Devine committed
913
914
	mp := ParseModelPath(name)

915
916
	fn(api.ProgressResponse{Status: "retrieving manifest"})

Patrick Devine's avatar
Patrick Devine committed
917
	manifest, err := GetManifest(mp)
918
	if err != nil {
919
		fn(api.ProgressResponse{Status: "couldn't retrieve manifest"})
920
921
922
923
		return err
	}

	var layers []*Layer
Jeffrey Morgan's avatar
Jeffrey Morgan committed
924
	layers = append(layers, manifest.Layers...)
925
926
927
	layers = append(layers, &manifest.Config)

	for _, layer := range layers {
928
		exists, err := checkBlobExistence(ctx, mp, layer.Digest, regOpts)
929
930
931
932
933
		if err != nil {
			return err
		}

		if exists {
934
935
936
			fn(api.ProgressResponse{
				Status:    "using existing layer",
				Digest:    layer.Digest,
937
938
				Total:     layer.Size,
				Completed: layer.Size,
939
			})
940
			log.Printf("Layer %s already exists", layer.Digest)
941
942
943
			continue
		}

944
		fn(api.ProgressResponse{
945
946
947
			Status: "starting upload",
			Digest: layer.Digest,
			Total:  layer.Size,
948
		})
949

950
		location, err := startUpload(ctx, mp, regOpts)
951
952
953
954
955
		if err != nil {
			log.Printf("couldn't start upload: %v", err)
			return err
		}

956
		err = uploadBlobChunked(ctx, mp, location, layer, regOpts, fn)
957
958
959
960
		if err != nil {
			log.Printf("error uploading blob: %v", err)
			return err
		}
961
962
	}

963
	fn(api.ProgressResponse{Status: "pushing manifest"})
964
	url := fmt.Sprintf("%s/v2/%s/manifests/%s", mp.Registry, mp.GetNamespaceRepository(), mp.Tag)
965
966
967
968
969
970
971
972
973
	headers := map[string]string{
		"Content-Type": "application/vnd.docker.distribution.manifest.v2+json",
	}

	manifestJSON, err := json.Marshal(manifest)
	if err != nil {
		return err
	}

974
	resp, err := makeRequest(ctx, "PUT", url, headers, bytes.NewReader(manifestJSON), regOpts)
975
976
977
978
979
980
981
982
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	// Check for success: For a successful upload, the Docker registry will respond with a 201 Created
	if resp.StatusCode != http.StatusCreated {
		body, _ := io.ReadAll(resp.Body)
983
		return fmt.Errorf("on push registry responded with code %d: %v", resp.StatusCode, string(body))
984
985
	}

986
	fn(api.ProgressResponse{Status: "success"})
987
988
989
990

	return nil
}

991
func PullModel(ctx context.Context, name string, regOpts *RegistryOptions, fn func(api.ProgressResponse)) error {
Patrick Devine's avatar
Patrick Devine committed
992
	mp := ParseModelPath(name)
993

994
	fn(api.ProgressResponse{Status: "pulling manifest"})
995

996
	manifest, err := pullModelManifest(ctx, mp, regOpts)
997
	if err != nil {
998
		return fmt.Errorf("pull model manifest: %s", err)
999
1000
1001
	}

	var layers []*Layer
Bruce MacDonald's avatar
Bruce MacDonald committed
1002
	layers = append(layers, manifest.Layers...)
1003
1004
1005
	layers = append(layers, &manifest.Config)

	for _, layer := range layers {
1006
		if err := downloadBlob(ctx, mp, layer.Digest, regOpts, fn); err != nil {
1007
1008
1009
1010
			return err
		}
	}

Michael Yang's avatar
Michael Yang committed
1011
1012
1013
	fn(api.ProgressResponse{Status: "verifying sha256 digest"})
	for _, layer := range layers {
		if err := verifyBlob(layer.Digest); err != nil {
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
			if errors.Is(err, errDigestMismatch) {
				// something went wrong, delete the blob
				fp, err := GetBlobsPath(layer.Digest)
				if err != nil {
					return err
				}
				if err := os.Remove(fp); err != nil {
					// log this, but return the original error
					log.Printf("couldn't remove file with digest mismatch '%s': %v", fp, err)
				}
			}
Michael Yang's avatar
Michael Yang committed
1025
1026
1027
1028
			return err
		}
	}

1029
	fn(api.ProgressResponse{Status: "writing manifest"})
1030

1031
	manifestJSON, err := json.Marshal(manifest)
1032
1033
1034
1035
	if err != nil {
		return err
	}

Patrick Devine's avatar
Patrick Devine committed
1036
	fp, err := mp.GetManifestPath(true)
1037
1038
1039
1040
	if err != nil {
		return err
	}

Bruce MacDonald's avatar
Bruce MacDonald committed
1041
	err = os.WriteFile(fp, manifestJSON, 0o644)
1042
1043
1044
1045
1046
	if err != nil {
		log.Printf("couldn't write to %s", fp)
		return err
	}

1047
	fn(api.ProgressResponse{Status: "success"})
1048
1049
1050
1051

	return nil
}

1052
func pullModelManifest(ctx context.Context, mp ModelPath, regOpts *RegistryOptions) (*ManifestV2, error) {
1053
	url := fmt.Sprintf("%s/v2/%s/manifests/%s", mp.Registry, mp.GetNamespaceRepository(), mp.Tag)
1054
1055
1056
1057
	headers := map[string]string{
		"Accept": "application/vnd.docker.distribution.manifest.v2+json",
	}

1058
	resp, err := makeRequest(ctx, "GET", url, headers, nil, regOpts)
1059
1060
1061
1062
1063
1064
1065
1066
	if err != nil {
		log.Printf("couldn't get manifest: %v", err)
		return nil, err
	}
	defer resp.Body.Close()

	// Check for success: For a successful upload, the Docker registry will respond with a 201 Created
	if resp.StatusCode != http.StatusOK {
1067
		if resp.StatusCode == http.StatusNotFound {
Bruce MacDonald's avatar
Bruce MacDonald committed
1068
			return nil, fmt.Errorf("model not found")
1069
		}
1070
		body, _ := io.ReadAll(resp.Body)
1071
		return nil, fmt.Errorf("on pull registry responded with code %d: %s", resp.StatusCode, body)
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
	}

	var m *ManifestV2
	if err := json.NewDecoder(resp.Body).Decode(&m); err != nil {
		return nil, err
	}

	return m, err
}

1082
1083
1084
1085
func createConfigLayer(config ConfigV2, layers []string) (*LayerReader, error) {
	config.RootFS = RootFS{
		Type:    "layers",
		DiffIDs: layers,
1086
1087
1088
1089
1090
1091
1092
	}

	configJSON, err := json.Marshal(config)
	if err != nil {
		return nil, err
	}

1093
	digest, size := GetSHA256Digest(bytes.NewBuffer(configJSON))
1094

Michael Yang's avatar
Michael Yang committed
1095
	layer := &LayerReader{
1096
1097
1098
1099
1100
		Layer: Layer{
			MediaType: "application/vnd.docker.container.image.v1+json",
			Digest:    digest,
			Size:      size,
		},
1101
		Reader: bytes.NewBuffer(configJSON),
1102
1103
1104
1105
1106
	}
	return layer, nil
}

// GetSHA256Digest returns the SHA256 hash of a given buffer and returns it, and the size of buffer
Michael Yang's avatar
Michael Yang committed
1107
1108
1109
1110
1111
1112
1113
1114
func GetSHA256Digest(r io.Reader) (string, int) {
	h := sha256.New()
	n, err := io.Copy(h, r)
	if err != nil {
		log.Fatal(err)
	}

	return fmt.Sprintf("sha256:%x", h.Sum(nil)), int(n)
1115
1116
}

1117
func startUpload(ctx context.Context, mp ModelPath, regOpts *RegistryOptions) (string, error) {
1118
	url := fmt.Sprintf("%s/v2/%s/blobs/uploads/", mp.Registry, mp.GetNamespaceRepository())
1119

1120
	resp, err := makeRequest(ctx, "POST", url, nil, nil, regOpts)
1121
1122
1123
1124
1125
1126
1127
1128
1129
	if err != nil {
		log.Printf("couldn't start upload: %v", err)
		return "", err
	}
	defer resp.Body.Close()

	// Check for success
	if resp.StatusCode != http.StatusAccepted {
		body, _ := io.ReadAll(resp.Body)
1130
		return "", fmt.Errorf("on upload registry responded with code %d: %s", resp.StatusCode, body)
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
	}

	// Extract UUID location from header
	location := resp.Header.Get("Location")
	if location == "" {
		return "", fmt.Errorf("location header is missing in response")
	}

	return location, nil
}

// Function to check if a blob already exists in the Docker registry
1143
func checkBlobExistence(ctx context.Context, mp ModelPath, digest string, regOpts *RegistryOptions) (bool, error) {
1144
	url := fmt.Sprintf("%s/v2/%s/blobs/%s", mp.Registry, mp.GetNamespaceRepository(), digest)
1145

1146
	resp, err := makeRequest(ctx, "HEAD", url, nil, nil, regOpts)
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
	if err != nil {
		log.Printf("couldn't check for blob: %v", err)
		return false, err
	}
	defer resp.Body.Close()

	// Check for success: If the blob exists, the Docker registry will respond with a 200 OK
	return resp.StatusCode == http.StatusOK, nil
}

1157
func uploadBlobChunked(ctx context.Context, mp ModelPath, url string, layer *Layer, regOpts *RegistryOptions, fn func(api.ProgressResponse)) error {
1158
1159
1160
1161
	// TODO allow resumability
	// TODO allow canceling uploads via DELETE
	// TODO allow cross repo blob mount

Patrick Devine's avatar
Patrick Devine committed
1162
	fp, err := GetBlobsPath(layer.Digest)
1163
1164
1165
1166
	if err != nil {
		return err
	}

1167
1168
1169
1170
1171
	f, err := os.Open(fp)
	if err != nil {
		return err
	}

1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
	totalUploaded := 0

	r, w := io.Pipe()
	defer r.Close()

	go func() {
		defer w.Close()
		for {
			n, err := io.CopyN(w, f, 1024*1024)
			if err != nil && !errors.Is(err, io.EOF) {
				fn(api.ProgressResponse{
					Status:    fmt.Sprintf("error copying pipe: %v", err),
					Digest:    layer.Digest,
					Total:     layer.Size,
					Completed: totalUploaded,
				})
				return
			}
1190

1191
			totalUploaded += int(n)
1192
1193

			fn(api.ProgressResponse{
1194
				Status:    fmt.Sprintf("uploading %s", layer.Digest),
1195
				Digest:    layer.Digest,
1196
1197
				Total:     layer.Size,
				Completed: totalUploaded,
1198
			})
1199
1200
1201
1202

			if totalUploaded >= layer.Size {
				return
			}
1203
		}
1204
	}()
1205

1206
	url = fmt.Sprintf("%s&digest=%s", url, layer.Digest)
1207

1208
1209
1210
1211
	headers := make(map[string]string)
	headers["Content-Type"] = "application/octet-stream"
	headers["Content-Range"] = fmt.Sprintf("0-%d", layer.Size-1)
	headers["Content-Length"] = strconv.Itoa(int(layer.Size))
1212

1213
	// finish the upload
1214
	resp, err := makeRequest(ctx, "PUT", url, headers, r, regOpts)
1215
1216
1217
1218
1219
1220
1221
1222
1223
	if err != nil {
		log.Printf("couldn't finish upload: %v", err)
		return err
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusCreated {
		body, _ := io.ReadAll(resp.Body)
		return fmt.Errorf("on finish upload registry responded with code %d: %v", resp.StatusCode, string(body))
1224
	}
1225
1226
1227
	return nil
}

1228
1229
1230
1231
1232
1233
func makeRequest(ctx context.Context, method, url string, headers map[string]string, body io.Reader, regOpts *RegistryOptions) (*http.Response, error) {
	retryCtx := ctx.Value("retries")
	var retries int
	var ok bool
	if retries, ok = retryCtx.(int); ok {
		if retries > MaxRetries {
Bruce MacDonald's avatar
Bruce MacDonald committed
1234
			return nil, fmt.Errorf("maximum retries hit; are you sure you have access to this resource?")
1235
1236
1237
		}
	}

1238
1239
1240
1241
1242
1243
1244
1245
	if !strings.HasPrefix(url, "http") {
		if regOpts.Insecure {
			url = "http://" + url
		} else {
			url = "https://" + url
		}
	}

Patrick Devine's avatar
Patrick Devine committed
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
	// make a copy of the body in case we need to try the call to makeRequest again
	var buf bytes.Buffer
	if body != nil {
		_, err := io.Copy(&buf, body)
		if err != nil {
			return nil, err
		}
	}

	bodyCopy := bytes.NewReader(buf.Bytes())

	req, err := http.NewRequest(method, url, bodyCopy)
1258
1259
1260
1261
	if err != nil {
		return nil, err
	}

Patrick Devine's avatar
Patrick Devine committed
1262
1263
1264
1265
	if regOpts.Token != "" {
		req.Header.Set("Authorization", "Bearer "+regOpts.Token)
	} else if regOpts.Username != "" && regOpts.Password != "" {
		req.SetBasicAuth(regOpts.Username, regOpts.Password)
1266
1267
	}

Patrick Devine's avatar
Patrick Devine committed
1268
1269
	for k, v := range headers {
		req.Header.Set(k, v)
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
	}

	client := &http.Client{
		CheckRedirect: func(req *http.Request, via []*http.Request) error {
			if len(via) >= 10 {
				return fmt.Errorf("too many redirects")
			}
			log.Printf("redirected to: %s\n", req.URL)
			return nil
		},
	}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}

Patrick Devine's avatar
Patrick Devine committed
1286
1287
1288
1289
	// if the request is unauthenticated, try to authenticate and make the request again
	if resp.StatusCode == http.StatusUnauthorized {
		auth := resp.Header.Get("Www-Authenticate")
		authRedir := ParseAuthRedirectString(string(auth))
1290
		token, err := getAuthToken(ctx, authRedir, regOpts)
Patrick Devine's avatar
Patrick Devine committed
1291
1292
1293
1294
1295
		if err != nil {
			return nil, err
		}
		regOpts.Token = token
		bodyCopy = bytes.NewReader(buf.Bytes())
1296
1297
		ctx = context.WithValue(ctx, "retries", retries+1)
		return makeRequest(ctx, method, url, headers, bodyCopy, regOpts)
Patrick Devine's avatar
Patrick Devine committed
1298
1299
	}

1300
1301
	return resp, nil
}
Michael Yang's avatar
Michael Yang committed
1302

Patrick Devine's avatar
Patrick Devine committed
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
func getValue(header, key string) string {
	startIdx := strings.Index(header, key+"=")
	if startIdx == -1 {
		return ""
	}

	// Move the index to the starting quote after the key.
	startIdx += len(key) + 2
	endIdx := startIdx

	for endIdx < len(header) {
		if header[endIdx] == '"' {
			if endIdx+1 < len(header) && header[endIdx+1] != ',' { // If the next character isn't a comma, continue
				endIdx++
				continue
			}
			break
		}
		endIdx++
	}
	return header[startIdx:endIdx]
}

func ParseAuthRedirectString(authStr string) AuthRedirect {
	authStr = strings.TrimPrefix(authStr, "Bearer ")

	return AuthRedirect{
		Realm:   getValue(authStr, "realm"),
		Service: getValue(authStr, "service"),
		Scope:   getValue(authStr, "scope"),
	}
}

1336
1337
var errDigestMismatch = fmt.Errorf("digest mismatch, file must be downloaded again")

Michael Yang's avatar
Michael Yang committed
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
func verifyBlob(digest string) error {
	fp, err := GetBlobsPath(digest)
	if err != nil {
		return err
	}

	f, err := os.Open(fp)
	if err != nil {
		return err
	}
	defer f.Close()

	fileDigest, _ := GetSHA256Digest(f)
	if digest != fileDigest {
1352
		return fmt.Errorf("%w: want %s, got %s", errDigestMismatch, digest, fileDigest)
Michael Yang's avatar
Michael Yang committed
1353
1354
1355
1356
	}

	return nil
}