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

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

Michael Yang's avatar
Michael Yang committed
25
26
	"golang.org/x/exp/slices"

27
	"github.com/jmorganca/ollama/api"
28
	"github.com/jmorganca/ollama/llm"
29
	"github.com/jmorganca/ollama/parser"
30
	"github.com/jmorganca/ollama/vector"
Michael Yang's avatar
Michael Yang committed
31
	"github.com/jmorganca/ollama/version"
32
33
)

34
35
const MaxRetries = 3

36
37
38
39
type RegistryOptions struct {
	Insecure bool
	Username string
	Password string
Patrick Devine's avatar
Patrick Devine committed
40
	Token    string
41
42
}

43
type Model struct {
44
45
46
47
48
49
	Name         string `json:"name"`
	ModelPath    string
	AdapterPaths []string
	Template     string
	System       string
	Digest       string
Patrick Devine's avatar
Patrick Devine committed
50
	ConfigDigest string
51
52
	Options      map[string]interface{}
	Embeddings   []vector.Embedding
53
54
}

Bruce MacDonald's avatar
Bruce MacDonald committed
55
func (m *Model) Prompt(request api.GenerateRequest, embedding string) (string, error) {
56
57
58
59
60
61
	t := m.Template
	if request.Template != "" {
		t = request.Template
	}

	tmpl, err := template.New("").Parse(t)
62
63
64
65
66
	if err != nil {
		return "", err
	}

	var vars struct {
Michael Yang's avatar
Michael Yang committed
67
		First  bool
68
69
		System string
		Prompt string
70
		Embed  string
71
72
73

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

Michael Yang's avatar
Michael Yang committed
76
	vars.First = len(request.Context) == 0
77
78
	vars.System = m.System
	vars.Prompt = request.Prompt
Michael Yang's avatar
Michael Yang committed
79
	vars.Context = request.Context
Bruce MacDonald's avatar
Bruce MacDonald committed
80
	vars.Embed = embedding
81

82
83
84
85
	if request.System != "" {
		vars.System = request.System
	}

86
87
88
89
90
91
92
93
	var sb strings.Builder
	if err := tmpl.Execute(&sb, vars); err != nil {
		return "", err
	}

	return sb.String(), nil
}

94
95
96
97
98
99
100
101
102
103
104
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
105
	From      string `json:"from,omitempty"`
106
107
}

Michael Yang's avatar
Michael Yang committed
108
type LayerReader struct {
109
	Layer
Michael Yang's avatar
Michael Yang committed
110
	io.Reader
111
112
113
}

type ConfigV2 struct {
114
	ModelFamily llm.ModelFamily `json:"model_family"`
Michael Yang's avatar
fmt  
Michael Yang committed
115
116
117
	ModelType   string          `json:"model_type"`
	FileType    string          `json:"file_type"`
	RootFS      RootFS          `json:"rootfs"`
118
119

	// required by spec
120
121
122
123
124
125
126
127
128
	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
129
130
131
132
133
134
135
136
137
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
138
func GetManifest(mp ModelPath) (*ManifestV2, string, error) {
Patrick Devine's avatar
Patrick Devine committed
139
	fp, err := mp.GetManifestPath(false)
140
	if err != nil {
Patrick Devine's avatar
Patrick Devine committed
141
		return nil, "", err
142
	}
143

144
	if _, err = os.Stat(fp); err != nil {
Patrick Devine's avatar
Patrick Devine committed
145
		return nil, "", err
146
147
148
149
	}

	var manifest *ManifestV2

150
	bts, err := os.ReadFile(fp)
151
	if err != nil {
Patrick Devine's avatar
Patrick Devine committed
152
		return nil, "", fmt.Errorf("couldn't open file '%s'", fp)
153
154
	}

Patrick Devine's avatar
Patrick Devine committed
155
156
157
	shaSum := sha256.Sum256(bts)
	shaStr := hex.EncodeToString(shaSum[:])

158
	if err := json.Unmarshal(bts, &manifest); err != nil {
Patrick Devine's avatar
Patrick Devine committed
159
		return nil, "", err
160
161
	}

Patrick Devine's avatar
Patrick Devine committed
162
	return manifest, shaStr, nil
163
164
165
}

func GetModel(name string) (*Model, error) {
166
	mp := ParseModelPath(name)
Patrick Devine's avatar
Patrick Devine committed
167
	manifest, digest, err := GetManifest(mp)
168
169
170
171
172
	if err != nil {
		return nil, err
	}

	model := &Model{
Patrick Devine's avatar
Patrick Devine committed
173
174
175
176
		Name:         mp.GetFullTagname(),
		Digest:       digest,
		ConfigDigest: manifest.Config.Digest,
		Template:     "{{ .Prompt }}",
177
178
179
	}

	for _, layer := range manifest.Layers {
Patrick Devine's avatar
Patrick Devine committed
180
		filename, err := GetBlobsPath(layer.Digest)
181
182
183
184
		if err != nil {
			return nil, err
		}

185
186
187
		switch layer.MediaType {
		case "application/vnd.ollama.image.model":
			model.ModelPath = filename
188
189
190
191
192
193
194
195
196
197
		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
			}
198
199
		case "application/vnd.ollama.image.adapter":
			model.AdapterPaths = append(model.AdapterPaths, filename)
200
201
202
203
204
205
206
207
208
		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)
209
210
211
			if err != nil {
				return nil, err
			}
212
213

			model.System = string(bts)
214
215
216
217
218
219
220
		case "application/vnd.ollama.image.prompt":
			bts, err := os.ReadFile(filename)
			if err != nil {
				return nil, err
			}

			model.Template = string(bts)
221
		case "application/vnd.ollama.image.params":
Michael Yang's avatar
Michael Yang committed
222
223
224
225
226
			params, err := os.Open(filename)
			if err != nil {
				return nil, err
			}
			defer params.Close()
227

228
			// parse model options parameters into a map so that we can see which fields have been specified explicitly
229
			if err = json.NewDecoder(params).Decode(&model.Options); err != nil {
230
231
				return nil, err
			}
232
233
234
235
236
237
		}
	}

	return model, nil
}

238
239
func filenameWithPath(path, f string) (string, error) {
	// if filePath starts with ~/, replace it with the user's home directory.
Michael Yang's avatar
Michael Yang committed
240
241
	if strings.HasPrefix(f, fmt.Sprintf("~%s", string(os.PathSeparator))) {
		parts := strings.Split(f, string(os.PathSeparator))
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
		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
}

258
func CreateModel(ctx context.Context, name string, path string, fn func(resp api.ProgressResponse)) error {
259
260
	mf, err := os.Open(path)
	if err != nil {
261
		fn(api.ProgressResponse{Status: fmt.Sprintf("couldn't open modelfile '%s'", path)})
262
		return fmt.Errorf("failed to open file: %w", err)
263
	}
264
	defer mf.Close()
265

266
	fn(api.ProgressResponse{Status: "parsing modelfile"})
267
268
269
270
271
	commands, err := parser.Parse(mf)
	if err != nil {
		return err
	}

272
273
274
275
276
	config := ConfigV2{
		Architecture: "amd64",
		OS:           "linux",
	}

Michael Yang's avatar
Michael Yang committed
277
	var layers []*LayerReader
278
	params := make(map[string][]string)
279
	embed := EmbeddingParams{fn: fn}
280
	for _, c := range commands {
281
		log.Printf("[%s] - %s\n", c.Name, c.Args)
282
283
		switch c.Name {
		case "model":
284
			fn(api.ProgressResponse{Status: "looking for model"})
285
			embed.model = c.Args
286

287
			mp := ParseModelPath(c.Args)
Patrick Devine's avatar
Patrick Devine committed
288
			mf, _, err := GetManifest(mp)
289
			if err != nil {
290
291
292
				modelFile, err := filenameWithPath(path, c.Args)
				if err != nil {
					return err
293
				}
294
				if _, err := os.Stat(modelFile); err != nil {
295
296
297
					// the model file does not exist, try pulling it
					if errors.Is(err, os.ErrNotExist) {
						fn(api.ProgressResponse{Status: "pulling model file"})
298
						if err := PullModel(ctx, c.Args, &RegistryOptions{}, fn); err != nil {
299
300
							return err
						}
Patrick Devine's avatar
Patrick Devine committed
301
						mf, _, err = GetManifest(mp)
302
303
304
305
306
307
308
						if err != nil {
							return fmt.Errorf("failed to open file after pull: %v", err)
						}
					} else {
						return err
					}
				} else {
309
					embed.model = modelFile
310
311
					// create a model from this specified file
					fn(api.ProgressResponse{Status: "creating model layer"})
312
					file, err := os.Open(modelFile)
313
314
315
316
317
					if err != nil {
						return fmt.Errorf("failed to open file: %v", err)
					}
					defer file.Close()

318
319
320
321
322
					ggml, err := llm.DecodeGGML(file, llm.ModelFamilyLlama)
					if err != nil {
						return err
					}

Michael Yang's avatar
Michael Yang committed
323
324
325
					config.ModelFamily = ggml.ModelFamily()
					config.ModelType = ggml.ModelType().String()
					config.FileType = ggml.FileType().String()
326
327
328
329

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

330
331
332
333
334
335
					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)
336
				}
337
			}
338

339
			if mf != nil {
Michael Yang's avatar
Michael Yang committed
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
				sourceBlobPath, err := GetBlobsPath(mf.Config.Digest)
				if err != nil {
					return err
				}

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

				var source ConfigV2
				if err := json.NewDecoder(sourceBlob).Decode(&source); err != nil {
					return err
				}

				// copie the model metadata
				config.ModelFamily = source.ModelFamily
				config.ModelType = source.ModelType
				config.FileType = source.FileType

361
362
363
364
365
				for _, l := range mf.Layers {
					newLayer, err := GetLayerWithBufferFromLayer(l)
					if err != nil {
						return err
					}
Michael Yang's avatar
Michael Yang committed
366
					newLayer.From = mp.GetNamespaceRepository()
367
368
369
					layers = append(layers, newLayer)
				}
			}
370
371
		case "embed":
			embedFilePath, err := filenameWithPath(path, c.Args)
Michael Yang's avatar
Michael Yang committed
372
373
374
			if err != nil {
				return err
			}
375
			embed.files = append(embed.files, embedFilePath)
376
377
378
		case "adapter":
			fn(api.ProgressResponse{Status: fmt.Sprintf("creating model %s layer", c.Name)})

Michael Yang's avatar
Michael Yang committed
379
380
381
			fp, err := filenameWithPath(path, c.Args)
			if err != nil {
				return err
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
			}

			// 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
399
400
401
402
403
404
405
406
407
408
409
410
		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":
411
			fn(api.ProgressResponse{Status: fmt.Sprintf("creating model %s layer", c.Name)})
412
			// remove the layer if one exists
413
414
			mediaType := fmt.Sprintf("application/vnd.ollama.image.%s", c.Name)
			layers = removeLayerFromLayers(layers, mediaType)
415

416
			layer, err := CreateLayer(strings.NewReader(c.Args))
417
			if err != nil {
418
				return err
419
			}
420
421
422

			layer.MediaType = mediaType
			layers = append(layers, layer)
423
		default:
424
			// runtime parameters, build a list of args for each parameter to allow multiple values to be specified (ex: multiple stop sequences)
425
			params[c.Name] = append(params[c.Name], c.Args)
426
427
428
429
		}
	}

	// Create a single layer for the parameters
Michael Yang's avatar
Michael Yang committed
430
	if len(params) > 0 {
431
		fn(api.ProgressResponse{Status: "creating parameter layer"})
Michael Yang's avatar
Michael Yang committed
432

433
		layers = removeLayerFromLayers(layers, "application/vnd.ollama.image.params")
434
		formattedParams, err := formatParams(params)
435
436
437
		if err != nil {
			return fmt.Errorf("couldn't create params json: %v", err)
		}
438
439
440
441
442
443
444

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

		l, err := CreateLayer(bytes.NewReader(bts))
445
446
447
448
449
		if err != nil {
			return fmt.Errorf("failed to create layer: %v", err)
		}
		l.MediaType = "application/vnd.ollama.image.params"
		layers = append(layers, l)
450
451

		// apply these parameters to the embedding options, in case embeddings need to be generated using this model
452
		embed.opts = formattedParams
453
454
	}

455
456
457
458
459
460
461
	// generate the embedding layers
	embeddingLayers, err := embeddingLayers(embed)
	if err != nil {
		return err
	}
	layers = append(layers, embeddingLayers...)

462
463
464
465
466
467
468
469
470
471
472
	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
473
	fn(api.ProgressResponse{Status: "creating config layer"})
474
	cfg, err := createConfigLayer(config, digests)
475
476
477
478
479
	if err != nil {
		return err
	}
	layers = append(layers, cfg)

Michael Yang's avatar
Michael Yang committed
480
	if err := SaveLayers(layers, fn, false); err != nil {
481
482
483
484
		return err
	}

	// Create the manifest
485
	fn(api.ProgressResponse{Status: "writing manifest"})
486
487
488
489
490
	err = CreateManifest(name, cfg, manifestLayers)
	if err != nil {
		return err
	}

491
	fn(api.ProgressResponse{Status: "success"})
492
493
494
	return nil
}

495
496
type EmbeddingParams struct {
	model string
497
	opts  map[string]interface{}
498
499
500
501
502
503
504
505
	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 {
506
507
508
509
510
		// check if the model is a file path or a model name
		model, err := GetModel(e.model)
		if err != nil {
			if !strings.Contains(err.Error(), "couldn't open file") {
				return nil, fmt.Errorf("unexpected error opening model to generate embeddings: %v", err)
511
			}
512
513
			// the model may be a file path, create a model from this file
			model = &Model{ModelPath: e.model}
514
515
		}

516
		if err := load(context.Background(), model, e.opts, defaultSessionDuration); err != nil {
517
518
519
			return nil, fmt.Errorf("load model to generate embeddings: %v", err)
		}

520
		// this will be used to check if we already have embeddings for a file
521
		modelInfo, err := os.Stat(model.ModelPath)
522
		if err != nil {
Bruce MacDonald's avatar
Bruce MacDonald committed
523
			return nil, fmt.Errorf("failed to get model file info: %v", err)
524
525
		}

Bruce MacDonald's avatar
Bruce MacDonald committed
526
527
528
		addedFiles := make(map[string]bool) // keep track of files that have already been added
		for _, filePattern := range e.files {
			matchingFiles, err := filepath.Glob(filePattern)
529
			if err != nil {
Bruce MacDonald's avatar
Bruce MacDonald committed
530
				return nil, fmt.Errorf("could not find files with pattern %s: %w", filePattern, err)
531
532
			}

Bruce MacDonald's avatar
Bruce MacDonald committed
533
534
			for _, filePath := range matchingFiles {
				if addedFiles[filePath] {
535
536
					continue
				}
Bruce MacDonald's avatar
Bruce MacDonald committed
537
				addedFiles[filePath] = true
Bruce MacDonald's avatar
Bruce MacDonald committed
538
				// check if we already have embeddings for this file path
539
				layerIdentifier := fmt.Sprintf("%s:%s:%s:%d", filePath, e.model, modelInfo.ModTime().Format("2006-01-02 15:04:05"), modelInfo.Size())
Bruce MacDonald's avatar
Bruce MacDonald committed
540
541
542
543
544
545
				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
546
547
				// TODO: check file type
				f, err := os.Open(filePath)
548
				if err != nil {
Bruce MacDonald's avatar
Bruce MacDonald committed
549
					return nil, fmt.Errorf("could not open embed file: %w", err)
550
				}
Bruce MacDonald's avatar
Bruce MacDonald committed
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
				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
574
575
576
577
578
					if len(existing[d]) > 0 {
						// already have an embedding for this line
						embeddings = append(embeddings, vector.Embedding{Data: d, Vector: existing[d]})
						continue
					}
579
					embed, err := loaded.llm.Embedding(context.Background(), d)
Bruce MacDonald's avatar
Bruce MacDonald committed
580
					if err != nil {
581
582
						log.Printf("failed to generate embedding for '%s' line %d: %v", filePath, i+1, err)
						continue
Bruce MacDonald's avatar
Bruce MacDonald committed
583
584
					}
					embeddings = append(embeddings, vector.Embedding{Data: d, Vector: embed})
585
586
				}

Bruce MacDonald's avatar
Bruce MacDonald committed
587
588
589
590
591
				b, err := json.Marshal(embeddings)
				if err != nil {
					return nil, fmt.Errorf("failed to encode embeddings: %w", err)
				}
				r := bytes.NewReader(b)
592

Bruce MacDonald's avatar
Bruce MacDonald committed
593
594
595
596
				layer := &LayerReader{
					Layer: Layer{
						MediaType: "application/vnd.ollama.image.embed",
						Digest:    digest,
Bruce MacDonald's avatar
Bruce MacDonald committed
597
						Size:      r.Len(),
Bruce MacDonald's avatar
Bruce MacDonald committed
598
599
600
					},
					Reader: r,
				}
601

Bruce MacDonald's avatar
Bruce MacDonald committed
602
603
				layers = append(layers, layer)
			}
604
605
606
607
608
		}
	}
	return layers, nil
}

Bruce MacDonald's avatar
Bruce MacDonald committed
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
// 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
635
func removeLayerFromLayers(layers []*LayerReader, mediaType string) []*LayerReader {
Michael Yang's avatar
Michael Yang committed
636
637
638
	return slices.DeleteFunc(layers, func(layer *LayerReader) bool {
		return layer.MediaType == mediaType
	})
639
640
}

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

		_, err = os.Stat(fp)
Bruce MacDonald's avatar
Bruce MacDonald committed
650
651
		// 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" {
652
653
			fn(api.ProgressResponse{Status: fmt.Sprintf("writing layer %s", layer.Digest)})

654
655
656
657
658
659
660
			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
661
			if _, err = io.Copy(out, layer.Reader); err != nil {
662
663
				return err
			}
Michael Yang's avatar
Michael Yang committed
664

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

	return nil
}

Michael Yang's avatar
Michael Yang committed
673
func CreateManifest(name string, cfg *LayerReader, layers []*Layer) error {
674
	mp := ParseModelPath(name)
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
	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
691
	fp, err := mp.GetManifestPath(true)
692
693
694
	if err != nil {
		return err
	}
695
	return os.WriteFile(fp, manifestJSON, 0o644)
696
697
}

Michael Yang's avatar
Michael Yang committed
698
func GetLayerWithBufferFromLayer(layer *Layer) (*LayerReader, error) {
Patrick Devine's avatar
Patrick Devine committed
699
	fp, err := GetBlobsPath(layer.Digest)
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
	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
}

718
719
// formatParams converts specified parameter options to their correct types
func formatParams(params map[string][]string) (map[string]interface{}, error) {
720
721
722
	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
723

724
	// build map of json struct tags to their types
Michael Yang's avatar
Michael Yang committed
725
726
727
728
729
730
731
732
	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
		}
	}

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

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

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

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

773
	return out, nil
774
775
}

Michael Yang's avatar
Michael Yang committed
776
func getLayerDigests(layers []*LayerReader) ([]string, error) {
777
778
779
780
781
782
783
784
785
786
787
	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
788
789
func CreateLayer(f io.ReadSeeker) (*LayerReader, error) {
	digest, size := GetSHA256Digest(f)
790
	f.Seek(0, io.SeekStart)
791

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

	return layer, nil
}

Patrick Devine's avatar
Patrick Devine committed
804
func CopyModel(src, dest string) error {
805
	srcModelPath := ParseModelPath(src)
806
807
808
809
810
	srcPath, err := srcModelPath.GetManifestPath(false)
	if err != nil {
		return err
	}

811
	destModelPath := ParseModelPath(dest)
812
	destPath, err := destModelPath.GetManifestPath(true)
Patrick Devine's avatar
Patrick Devine committed
813
814
815
816
817
	if err != nil {
		return err
	}

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

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

	return nil
}

833
func DeleteModel(name string) error {
834
	mp := ParseModelPath(name)
Patrick Devine's avatar
Patrick Devine committed
835
	manifest, _, err := GetManifest(mp)
836
837
838
839
840
841
842
843
844
845
846
847
848
	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
	}
Michael Yang's avatar
Michael Yang committed
849
850
851
852

	walkFunc := func(path string, info os.FileInfo, _ error) error {
		if info.IsDir() {
			return nil
853
854
		}

Michael Yang's avatar
Michael Yang committed
855
856
857
858
		dir, file := filepath.Split(path)
		dir = strings.Trim(strings.TrimPrefix(dir, fp), string(os.PathSeparator))
		tag := strings.Join([]string{dir, file}, ":")
		fmp := ParseModelPath(tag)
859

Michael Yang's avatar
Michael Yang committed
860
861
862
		// skip the manifest we're trying to delete
		if mp.GetFullTagname() == fmp.GetFullTagname() {
			return nil
863
		}
Michael Yang's avatar
Michael Yang committed
864
865
866
867
868
869
870
871
872
873
874
875
876

		// 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)
877
		return nil
Michael Yang's avatar
Michael Yang committed
878
879
880
	}

	if err := filepath.Walk(fp, walkFunc); err != nil {
Michael Yang's avatar
Michael Yang committed
881
882
		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 {
913
	mp := ParseModelPath(name)
914
915
	fn(api.ProgressResponse{Status: "retrieving manifest"})

916
917
918
919
	if mp.ProtocolScheme == "http" && !regOpts.Insecure {
		return fmt.Errorf("insecure protocol http")
	}

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

	var layers []*Layer
Jeffrey Morgan's avatar
Jeffrey Morgan committed
927
	layers = append(layers, manifest.Layers...)
928
929
930
	layers = append(layers, &manifest.Config)

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

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

947
		fn(api.ProgressResponse{
948
949
950
			Status: "starting upload",
			Digest: layer.Digest,
			Total:  layer.Size,
951
		})
952

Michael Yang's avatar
Michael Yang committed
953
		location, err := startUpload(ctx, mp, layer, regOpts)
954
955
956
957
958
		if err != nil {
			log.Printf("couldn't start upload: %v", err)
			return err
		}

Michael Yang's avatar
Michael Yang committed
959
960
		if strings.HasPrefix(path.Base(location.Path), "sha256:") {
			layer.Digest = path.Base(location.Path)
Michael Yang's avatar
Michael Yang committed
961
962
963
964
965
966
967
968
969
			fn(api.ProgressResponse{
				Status:    "using existing layer",
				Digest:    layer.Digest,
				Total:     layer.Size,
				Completed: layer.Size,
			})
			continue
		}

Michael Yang's avatar
Michael Yang committed
970
		if err := uploadBlobChunked(ctx, location, layer, regOpts, fn); err != nil {
971
972
973
			log.Printf("error uploading blob: %v", err)
			return err
		}
974
975
	}

976
	fn(api.ProgressResponse{Status: "pushing manifest"})
Michael Yang's avatar
Michael Yang committed
977
978
	requestURL := mp.BaseURL()
	requestURL = requestURL.JoinPath("v2", mp.GetNamespaceRepository(), "manifests", mp.Tag)
979
980
981
982
983
984

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

Michael Yang's avatar
Michael Yang committed
985
986
	headers := make(http.Header)
	headers.Set("Content-Type", "application/vnd.docker.distribution.manifest.v2+json")
Michael Yang's avatar
Michael Yang committed
987
	resp, err := makeRequestWithRetry(ctx, "PUT", requestURL, headers, bytes.NewReader(manifestJSON), regOpts)
988
989
990
991
992
	if err != nil {
		return err
	}
	defer resp.Body.Close()

993
	fn(api.ProgressResponse{Status: "success"})
994
995
996
997

	return nil
}

998
func PullModel(ctx context.Context, name string, regOpts *RegistryOptions, fn func(api.ProgressResponse)) error {
999
1000
1001
1002
	mp := ParseModelPath(name)

	if mp.ProtocolScheme == "http" && !regOpts.Insecure {
		return fmt.Errorf("insecure protocol http")
1003
	}
1004

1005
	fn(api.ProgressResponse{Status: "pulling manifest"})
1006

1007
	manifest, err := pullModelManifest(ctx, mp, regOpts)
1008
	if err != nil {
1009
		return fmt.Errorf("pull model manifest: %s", err)
1010
1011
1012
	}

	var layers []*Layer
Bruce MacDonald's avatar
Bruce MacDonald committed
1013
	layers = append(layers, manifest.Layers...)
1014
1015
1016
	layers = append(layers, &manifest.Config)

	for _, layer := range layers {
1017
1018
1019
1020
1021
1022
1023
1024
		if err := downloadBlob(
			ctx,
			downloadOpts{
				mp:      mp,
				digest:  layer.Digest,
				regOpts: regOpts,
				fn:      fn,
			}); err != nil {
1025
1026
1027
1028
			return err
		}
	}

Michael Yang's avatar
Michael Yang committed
1029
1030
1031
	fn(api.ProgressResponse{Status: "verifying sha256 digest"})
	for _, layer := range layers {
		if err := verifyBlob(layer.Digest); err != nil {
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
			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
1043
1044
1045
1046
			return err
		}
	}

1047
	fn(api.ProgressResponse{Status: "writing manifest"})
1048

1049
	manifestJSON, err := json.Marshal(manifest)
1050
1051
1052
1053
	if err != nil {
		return err
	}

Patrick Devine's avatar
Patrick Devine committed
1054
	fp, err := mp.GetManifestPath(true)
1055
1056
1057
1058
	if err != nil {
		return err
	}

Bruce MacDonald's avatar
Bruce MacDonald committed
1059
	err = os.WriteFile(fp, manifestJSON, 0o644)
1060
1061
1062
1063
1064
	if err != nil {
		log.Printf("couldn't write to %s", fp)
		return err
	}

1065
	fn(api.ProgressResponse{Status: "success"})
1066
1067
1068
1069

	return nil
}

1070
func pullModelManifest(ctx context.Context, mp ModelPath, regOpts *RegistryOptions) (*ManifestV2, error) {
Michael Yang's avatar
Michael Yang committed
1071
	requestURL := mp.BaseURL().JoinPath("v2", mp.GetNamespaceRepository(), "manifests", mp.Tag)
1072

Michael Yang's avatar
Michael Yang committed
1073
1074
	headers := make(http.Header)
	headers.Set("Accept", "application/vnd.docker.distribution.manifest.v2+json")
Michael Yang's avatar
Michael Yang committed
1075
	resp, err := makeRequest(ctx, "GET", requestURL, headers, nil, regOpts)
1076
1077
1078
1079
1080
1081
	if err != nil {
		log.Printf("couldn't get manifest: %v", err)
		return nil, err
	}
	defer resp.Body.Close()

Michael Yang's avatar
Michael Yang committed
1082
	if resp.StatusCode >= http.StatusBadRequest {
1083
		if resp.StatusCode == http.StatusNotFound {
Bruce MacDonald's avatar
Bruce MacDonald committed
1084
			return nil, fmt.Errorf("model not found")
1085
		}
Michael Yang's avatar
Michael Yang committed
1086

1087
		body, _ := io.ReadAll(resp.Body)
1088
		return nil, fmt.Errorf("on pull registry responded with code %d: %s", resp.StatusCode, body)
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
	}

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

	return m, err
}

1099
1100
1101
1102
func createConfigLayer(config ConfigV2, layers []string) (*LayerReader, error) {
	config.RootFS = RootFS{
		Type:    "layers",
		DiffIDs: layers,
1103
1104
1105
1106
1107
1108
1109
	}

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

1110
	digest, size := GetSHA256Digest(bytes.NewBuffer(configJSON))
1111

Michael Yang's avatar
Michael Yang committed
1112
	layer := &LayerReader{
1113
1114
1115
1116
1117
		Layer: Layer{
			MediaType: "application/vnd.docker.container.image.v1+json",
			Digest:    digest,
			Size:      size,
		},
1118
		Reader: bytes.NewBuffer(configJSON),
1119
1120
1121
1122
1123
	}
	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
1124
1125
1126
1127
1128
1129
1130
1131
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)
1132
1133
1134
}

// Function to check if a blob already exists in the Docker registry
1135
func checkBlobExistence(ctx context.Context, mp ModelPath, digest string, regOpts *RegistryOptions) (bool, error) {
Michael Yang's avatar
Michael Yang committed
1136
1137
	requestURL := mp.BaseURL()
	requestURL = requestURL.JoinPath("v2", mp.GetNamespaceRepository(), "blobs", digest)
1138

Michael Yang's avatar
Michael Yang committed
1139
	resp, err := makeRequest(ctx, "HEAD", requestURL, nil, nil, regOpts)
1140
1141
1142
1143
1144
1145
1146
	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
Michael Yang's avatar
Michael Yang committed
1147
	return resp.StatusCode < http.StatusBadRequest, nil
1148
1149
}

Michael Yang's avatar
Michael Yang committed
1150
func makeRequestWithRetry(ctx context.Context, method string, requestURL *url.URL, headers http.Header, body io.ReadSeeker, regOpts *RegistryOptions) (*http.Response, error) {
Michael Yang's avatar
Michael Yang committed
1151
1152
	var status string
	for try := 0; try < MaxRetries; try++ {
Michael Yang's avatar
Michael Yang committed
1153
		resp, err := makeRequest(ctx, method, requestURL, headers, body, regOpts)
Michael Yang's avatar
Michael Yang committed
1154
1155
1156
1157
1158
1159
1160
		if err != nil {
			log.Printf("couldn't start upload: %v", err)
			return nil, err
		}

		status = resp.Status

Michael Yang's avatar
Michael Yang committed
1161
1162
		switch {
		case resp.StatusCode == http.StatusUnauthorized:
Michael Yang's avatar
Michael Yang committed
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
			auth := resp.Header.Get("www-authenticate")
			authRedir := ParseAuthRedirectString(auth)
			token, err := getAuthToken(ctx, authRedir, regOpts)
			if err != nil {
				return nil, err
			}

			regOpts.Token = token
			if body != nil {
				if _, err := body.Seek(0, io.SeekStart); err != nil {
					return nil, err
				}
			}

			continue
Michael Yang's avatar
Michael Yang committed
1178
		case resp.StatusCode >= http.StatusBadRequest:
Michael Yang's avatar
Michael Yang committed
1179
1180
			body, _ := io.ReadAll(resp.Body)
			return nil, fmt.Errorf("on upload registry responded with code %d: %s", resp.StatusCode, body)
Michael Yang's avatar
Michael Yang committed
1181
1182
		default:
			return resp, nil
Michael Yang's avatar
Michael Yang committed
1183
1184
1185
1186
1187
1188
		}
	}

	return nil, fmt.Errorf("max retry exceeded: %v", status)
}

Michael Yang's avatar
Michael Yang committed
1189
1190
1191
func makeRequest(ctx context.Context, method string, requestURL *url.URL, headers http.Header, body io.Reader, regOpts *RegistryOptions) (*http.Response, error) {
	if requestURL.Scheme != "http" && regOpts.Insecure {
		requestURL.Scheme = "http"
1192
1193
	}

Michael Yang's avatar
Michael Yang committed
1194
	req, err := http.NewRequestWithContext(ctx, method, requestURL.String(), body)
1195
1196
1197
1198
	if err != nil {
		return nil, err
	}

Michael Yang's avatar
Michael Yang committed
1199
1200
1201
1202
	if headers != nil {
		req.Header = headers
	}

Patrick Devine's avatar
Patrick Devine committed
1203
1204
1205
1206
	if regOpts.Token != "" {
		req.Header.Set("Authorization", "Bearer "+regOpts.Token)
	} else if regOpts.Username != "" && regOpts.Password != "" {
		req.SetBasicAuth(regOpts.Username, regOpts.Password)
1207
1208
	}

Michael Yang's avatar
Michael Yang committed
1209
	req.Header.Set("User-Agent", fmt.Sprintf("ollama/%s (%s %s) Go/%s", version.Version, runtime.GOARCH, runtime.GOOS, runtime.Version()))
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219

	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
		},
	}
Michael Yang's avatar
Michael Yang committed
1220

1221
1222
1223
1224
1225
1226
1227
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}

	return resp, nil
}
Michael Yang's avatar
Michael Yang committed
1228

Patrick Devine's avatar
Patrick Devine committed
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
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"),
	}
}

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

Michael Yang's avatar
Michael Yang committed
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
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 {
1278
		return fmt.Errorf("%w: want %s, got %s", errDigestMismatch, digest, fileDigest)
Michael Yang's avatar
Michael Yang committed
1279
1280
1281
1282
	}

	return nil
}