images.go 34.8 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
	"io"
	"log"
	"net/http"
	"os"
Michael Yang's avatar
Michael Yang committed
16
	"path"
17
	"path/filepath"
Michael Yang's avatar
Michael Yang committed
18
	"reflect"
Michael Yang's avatar
Michael Yang committed
19
	"runtime"
20
21
22
23
	"strconv"
	"strings"

	"github.com/jmorganca/ollama/api"
24
	"github.com/jmorganca/ollama/llm"
25
	"github.com/jmorganca/ollama/parser"
26
	"github.com/jmorganca/ollama/vector"
Michael Yang's avatar
Michael Yang committed
27
	"github.com/jmorganca/ollama/version"
28
29
)

30
31
const MaxRetries = 3

32
33
34
35
type RegistryOptions struct {
	Insecure bool
	Username string
	Password string
Patrick Devine's avatar
Patrick Devine committed
36
	Token    string
37
38
}

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

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

	tmpl, err := template.New("").Parse(t)
57
58
59
60
61
	if err != nil {
		return "", err
	}

	var vars struct {
Michael Yang's avatar
Michael Yang committed
62
		First  bool
63
64
		System string
		Prompt string
65
		Embed  string
66
67
68

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

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

77
78
79
80
	if request.System != "" {
		vars.System = request.System
	}

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

	return sb.String(), nil
}

89
90
91
92
93
94
95
96
97
98
99
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
100
	From      string `json:"from,omitempty"`
101
102
}

Michael Yang's avatar
Michael Yang committed
103
type LayerReader struct {
104
	Layer
Michael Yang's avatar
Michael Yang committed
105
	io.Reader
106
107
108
}

type ConfigV2 struct {
109
	ModelFamily llm.ModelFamily `json:"model_family"`
Michael Yang's avatar
fmt  
Michael Yang committed
110
111
112
	ModelType   string          `json:"model_type"`
	FileType    string          `json:"file_type"`
	RootFS      RootFS          `json:"rootfs"`
113
114

	// required by spec
115
116
117
118
119
120
121
122
123
	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
124
125
126
127
128
129
130
131
132
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
133
134
func GetManifest(mp ModelPath) (*ManifestV2, error) {
	fp, err := mp.GetManifestPath(false)
135
136
137
	if err != nil {
		return nil, err
	}
138

139
140
	if _, err = os.Stat(fp); err != nil {
		return nil, err
141
142
143
144
	}

	var manifest *ManifestV2

145
	bts, err := os.ReadFile(fp)
146
147
148
149
	if err != nil {
		return nil, fmt.Errorf("couldn't open file '%s'", fp)
	}

150
	if err := json.Unmarshal(bts, &manifest); err != nil {
151
152
153
154
155
156
157
		return nil, err
	}

	return manifest, nil
}

func GetModel(name string) (*Model, error) {
158
	mp := ParseModelPath(name)
Patrick Devine's avatar
Patrick Devine committed
159
	manifest, err := GetManifest(mp)
160
161
162
163
164
	if err != nil {
		return nil, err
	}

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

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

175
176
177
		switch layer.MediaType {
		case "application/vnd.ollama.image.model":
			model.ModelPath = filename
178
179
180
181
182
183
184
185
186
187
		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
			}
188
189
		case "application/vnd.ollama.image.adapter":
			model.AdapterPaths = append(model.AdapterPaths, filename)
190
191
192
193
194
195
196
197
198
		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)
199
200
201
			if err != nil {
				return nil, err
			}
202
203

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

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

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

	return model, nil
}

228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
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
}

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

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

262
263
264
265
266
	config := ConfigV2{
		Architecture: "amd64",
		OS:           "linux",
	}

Michael Yang's avatar
Michael Yang committed
267
	var layers []*LayerReader
268
	params := make(map[string][]string)
269
	embed := EmbeddingParams{fn: fn}
270
	for _, c := range commands {
271
		log.Printf("[%s] - %s\n", c.Name, c.Args)
272
273
		switch c.Name {
		case "model":
274
			fn(api.ProgressResponse{Status: "looking for model"})
275
			embed.model = c.Args
276

277
			mp := ParseModelPath(c.Args)
Michael Yang's avatar
Michael Yang committed
278
			mf, err := GetManifest(mp)
279
			if err != nil {
280
281
282
				modelFile, err := filenameWithPath(path, c.Args)
				if err != nil {
					return err
283
				}
284
				if _, err := os.Stat(modelFile); err != nil {
285
286
287
					// the model file does not exist, try pulling it
					if errors.Is(err, os.ErrNotExist) {
						fn(api.ProgressResponse{Status: "pulling model file"})
288
						if err := PullModel(ctx, c.Args, &RegistryOptions{}, fn); err != nil {
289
290
							return err
						}
291
						mf, err = GetManifest(mp)
292
293
294
295
296
297
298
						if err != nil {
							return fmt.Errorf("failed to open file after pull: %v", err)
						}
					} else {
						return err
					}
				} else {
299
					embed.model = modelFile
300
301
					// create a model from this specified file
					fn(api.ProgressResponse{Status: "creating model layer"})
302
					file, err := os.Open(modelFile)
303
304
305
306
307
					if err != nil {
						return fmt.Errorf("failed to open file: %v", err)
					}
					defer file.Close()

308
309
310
311
312
					ggml, err := llm.DecodeGGML(file, llm.ModelFamilyLlama)
					if err != nil {
						return err
					}

Michael Yang's avatar
Michael Yang committed
313
314
315
					config.ModelFamily = ggml.ModelFamily()
					config.ModelType = ggml.ModelType().String()
					config.FileType = ggml.FileType().String()
316
317
318
319

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

320
321
322
323
324
325
					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)
326
				}
327
			}
328

329
			if mf != nil {
Michael Yang's avatar
Michael Yang committed
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
				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

351
352
353
354
355
				for _, l := range mf.Layers {
					newLayer, err := GetLayerWithBufferFromLayer(l)
					if err != nil {
						return err
					}
Michael Yang's avatar
Michael Yang committed
356
					newLayer.From = mp.GetNamespaceRepository()
357
358
359
					layers = append(layers, newLayer)
				}
			}
360
361
		case "embed":
			embedFilePath, err := filenameWithPath(path, c.Args)
Michael Yang's avatar
Michael Yang committed
362
363
364
			if err != nil {
				return err
			}
365
			embed.files = append(embed.files, embedFilePath)
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
		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
400
401
402
403
404
405
406
407
408
409
410
411
		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":
412
			fn(api.ProgressResponse{Status: fmt.Sprintf("creating model %s layer", c.Name)})
413
			// remove the layer if one exists
414
415
			mediaType := fmt.Sprintf("application/vnd.ollama.image.%s", c.Name)
			layers = removeLayerFromLayers(layers, mediaType)
416

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

			layer.MediaType = mediaType
			layers = append(layers, layer)
424
		default:
425
426
			// 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)
427
428
429
430
		}
	}

	// Create a single layer for the parameters
Michael Yang's avatar
Michael Yang committed
431
	if len(params) > 0 {
432
		fn(api.ProgressResponse{Status: "creating parameter layer"})
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(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(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 {
636
637
638
639
640
641
642
643
644
645
	j := 0
	for _, l := range layers {
		if l.MediaType != mediaType {
			layers[j] = l
			j++
		}
	}
	return layers[:j]
}

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

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

659
660
661
662
663
664
665
			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
666
			if _, err = io.Copy(out, layer.Reader); err != nil {
667
668
				return err
			}
Michael Yang's avatar
Michael Yang committed
669

670
		} else {
671
			fn(api.ProgressResponse{Status: fmt.Sprintf("using already created layer %s", layer.Digest)})
672
673
674
675
676
677
		}
	}

	return nil
}

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

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

723
724
// formatParams converts specified parameter options to their correct types
func formatParams(params map[string][]string) (map[string]interface{}, error) {
725
726
727
	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
728

729
	// build map of json struct tags to their types
Michael Yang's avatar
Michael Yang committed
730
731
732
733
734
735
736
737
	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
		}
	}

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

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

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

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

778
	return out, nil
779
780
}

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

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

	return layer, nil
}

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

816
	destModelPath := ParseModelPath(dest)
817
	destPath, err := destModelPath.GetManifestPath(true)
Patrick Devine's avatar
Patrick Devine committed
818
819
820
821
822
	if err != nil {
		return err
	}

	// copy the file
Michael Yang's avatar
Michael Yang committed
823
	input, err := os.ReadFile(srcPath)
Patrick Devine's avatar
Patrick Devine committed
824
825
826
827
828
	if err != nil {
		fmt.Println("Error reading file:", err)
		return err
	}

Michael Yang's avatar
Michael Yang committed
829
	err = os.WriteFile(destPath, input, 0o644)
Patrick Devine's avatar
Patrick Devine committed
830
831
832
833
834
835
836
837
	if err != nil {
		fmt.Println("Error reading file:", err)
		return err
	}

	return nil
}

838
func DeleteModel(name string) error {
839
	mp := ParseModelPath(name)
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
	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:]
865
			fmp := ParseModelPath(tag)
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884

			// 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
885
886
887
	if err != nil {
		return err
	}
888
889
890
891

	// only delete the files which are still in the deleteMap
	for k, v := range deleteMap {
		if v {
892
			fp, err := GetBlobsPath(k)
893
			if err != nil {
894
895
896
897
898
				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)
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
				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
}

917
func PushModel(ctx context.Context, name string, regOpts *RegistryOptions, fn func(api.ProgressResponse)) error {
918
	mp := ParseModelPath(name)
919
920
	fn(api.ProgressResponse{Status: "retrieving manifest"})

921
922
923
924
	if mp.ProtocolScheme == "http" && !regOpts.Insecure {
		return fmt.Errorf("insecure protocol http")
	}

Patrick Devine's avatar
Patrick Devine committed
925
	manifest, err := GetManifest(mp)
926
	if err != nil {
927
		fn(api.ProgressResponse{Status: "couldn't retrieve manifest"})
928
929
930
931
		return err
	}

	var layers []*Layer
Jeffrey Morgan's avatar
Jeffrey Morgan committed
932
	layers = append(layers, manifest.Layers...)
933
934
935
	layers = append(layers, &manifest.Config)

	for _, layer := range layers {
936
		exists, err := checkBlobExistence(ctx, mp, layer.Digest, regOpts)
937
938
939
940
941
		if err != nil {
			return err
		}

		if exists {
942
943
944
			fn(api.ProgressResponse{
				Status:    "using existing layer",
				Digest:    layer.Digest,
945
946
				Total:     layer.Size,
				Completed: layer.Size,
947
			})
948
			log.Printf("Layer %s already exists", layer.Digest)
949
950
951
			continue
		}

952
		fn(api.ProgressResponse{
953
954
955
			Status: "starting upload",
			Digest: layer.Digest,
			Total:  layer.Size,
956
		})
957

Michael Yang's avatar
Michael Yang committed
958
		location, err := startUpload(ctx, mp, layer, regOpts)
959
960
961
962
963
		if err != nil {
			log.Printf("couldn't start upload: %v", err)
			return err
		}

Michael Yang's avatar
Michael Yang committed
964
965
966
967
968
969
970
971
972
973
974
975
		if strings.HasPrefix(path.Base(location), "sha256:") {
			layer.Digest = path.Base(location)
			fn(api.ProgressResponse{
				Status:    "using existing layer",
				Digest:    layer.Digest,
				Total:     layer.Size,
				Completed: layer.Size,
			})
			continue
		}

		if err := uploadBlobChunked(ctx, mp, location, layer, regOpts, fn); err != nil {
976
977
978
			log.Printf("error uploading blob: %v", err)
			return err
		}
979
980
	}

981
	fn(api.ProgressResponse{Status: "pushing manifest"})
982
	url := fmt.Sprintf("%s/v2/%s/manifests/%s", mp.Registry, mp.GetNamespaceRepository(), mp.Tag)
983
984
985
986
987
988

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

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

997
	fn(api.ProgressResponse{Status: "success"})
998
999
1000
1001

	return nil
}

1002
func PullModel(ctx context.Context, name string, regOpts *RegistryOptions, fn func(api.ProgressResponse)) error {
1003
1004
1005
1006
	mp := ParseModelPath(name)

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

1009
	fn(api.ProgressResponse{Status: "pulling manifest"})
1010

1011
	manifest, err := pullModelManifest(ctx, mp, regOpts)
1012
	if err != nil {
1013
		return fmt.Errorf("pull model manifest: %s", err)
1014
1015
1016
	}

	var layers []*Layer
Bruce MacDonald's avatar
Bruce MacDonald committed
1017
	layers = append(layers, manifest.Layers...)
1018
1019
1020
	layers = append(layers, &manifest.Config)

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

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

1051
	fn(api.ProgressResponse{Status: "writing manifest"})
1052

1053
	manifestJSON, err := json.Marshal(manifest)
1054
1055
1056
1057
	if err != nil {
		return err
	}

Patrick Devine's avatar
Patrick Devine committed
1058
	fp, err := mp.GetManifestPath(true)
1059
1060
1061
1062
	if err != nil {
		return err
	}

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

1069
	fn(api.ProgressResponse{Status: "success"})
1070
1071
1072
1073

	return nil
}

1074
func pullModelManifest(ctx context.Context, mp ModelPath, regOpts *RegistryOptions) (*ManifestV2, error) {
1075
	url := fmt.Sprintf("%s/v2/%s/manifests/%s", mp.Registry, mp.GetNamespaceRepository(), mp.Tag)
1076

Michael Yang's avatar
Michael Yang committed
1077
1078
	headers := make(http.Header)
	headers.Set("Accept", "application/vnd.docker.distribution.manifest.v2+json")
1079
	resp, err := makeRequest(ctx, "GET", url, headers, nil, regOpts)
1080
1081
1082
1083
1084
1085
1086
1087
	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 {
1088
		if resp.StatusCode == http.StatusNotFound {
Bruce MacDonald's avatar
Bruce MacDonald committed
1089
			return nil, fmt.Errorf("model not found")
1090
		}
1091
		body, _ := io.ReadAll(resp.Body)
1092
		return nil, fmt.Errorf("on pull registry responded with code %d: %s", resp.StatusCode, body)
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
	}

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

	return m, err
}

1103
1104
1105
1106
func createConfigLayer(config ConfigV2, layers []string) (*LayerReader, error) {
	config.RootFS = RootFS{
		Type:    "layers",
		DiffIDs: layers,
1107
1108
1109
1110
1111
1112
1113
	}

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

1114
	digest, size := GetSHA256Digest(bytes.NewBuffer(configJSON))
1115

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

Michael Yang's avatar
Michael Yang committed
1138
1139
type requestContextKey string

Michael Yang's avatar
Michael Yang committed
1140
func startUpload(ctx context.Context, mp ModelPath, layer *Layer, regOpts *RegistryOptions) (string, error) {
1141
	url := fmt.Sprintf("%s/v2/%s/blobs/uploads/", mp.Registry, mp.GetNamespaceRepository())
Michael Yang's avatar
Michael Yang committed
1142
1143
1144
	if layer.From != "" {
		url = fmt.Sprintf("%s/v2/%s/blobs/uploads/?mount=%s&from=%s", mp.Registry, mp.GetNamespaceRepository(), layer.Digest, layer.From)
	}
1145

Michael Yang's avatar
Michael Yang committed
1146
	resp, err := makeRequestWithRetry(ctx, "POST", url, nil, nil, regOpts)
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
	if err != nil {
		log.Printf("couldn't start upload: %v", err)
		return "", err
	}
	defer resp.Body.Close()

	// 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
1163
func checkBlobExistence(ctx context.Context, mp ModelPath, digest string, regOpts *RegistryOptions) (bool, error) {
1164
	url := fmt.Sprintf("%s/v2/%s/blobs/%s", mp.Registry, mp.GetNamespaceRepository(), digest)
1165

1166
	resp, err := makeRequest(ctx, "HEAD", url, nil, nil, regOpts)
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
	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
}

1177
func uploadBlobChunked(ctx context.Context, mp ModelPath, url string, layer *Layer, regOpts *RegistryOptions, fn func(api.ProgressResponse)) error {
1178
1179
1180
	// TODO allow resumability
	// TODO allow canceling uploads via DELETE

Patrick Devine's avatar
Patrick Devine committed
1181
	fp, err := GetBlobsPath(layer.Digest)
1182
1183
1184
1185
	if err != nil {
		return err
	}

1186
1187
1188
1189
	f, err := os.Open(fp)
	if err != nil {
		return err
	}
Michael Yang's avatar
Michael Yang committed
1190
	defer f.Close()
1191

1192
	var completed int64
Michael Yang's avatar
Michael Yang committed
1193
	chunkSize := 10 * 1024 * 1024
1194

Michael Yang's avatar
Michael Yang committed
1195
	for {
1196
1197
1198
		chunk := int64(layer.Size) - completed
		if chunk > int64(chunkSize) {
			chunk = int64(chunkSize)
Michael Yang's avatar
Michael Yang committed
1199
1200
		}

1201
		sectionReader := io.NewSectionReader(f, int64(completed), chunk)
1202

Michael Yang's avatar
Michael Yang committed
1203
1204
1205
1206
		headers := make(http.Header)
		headers.Set("Content-Type", "application/octet-stream")
		headers.Set("Content-Length", strconv.Itoa(int(chunk)))
		headers.Set("Content-Range", fmt.Sprintf("%d-%d", completed, completed+sectionReader.Size()-1))
1207
1208
1209
1210
1211
1212
1213
1214
		resp, err := makeRequestWithRetry(ctx, "PATCH", url, headers, sectionReader, regOpts)
		if err != nil && !errors.Is(err, io.EOF) {
			fn(api.ProgressResponse{
				Status:    fmt.Sprintf("error uploading chunk: %v", err),
				Digest:    layer.Digest,
				Total:     layer.Size,
				Completed: int(completed),
			})
1215

Michael Yang's avatar
Michael Yang committed
1216
1217
1218
			return err
		}
		defer resp.Body.Close()
1219

1220
1221
1222
1223
1224
1225
1226
		completed += sectionReader.Size()
		fn(api.ProgressResponse{
			Status:    fmt.Sprintf("uploading %s", layer.Digest),
			Digest:    layer.Digest,
			Total:     layer.Size,
			Completed: int(completed),
		})
Michael Yang's avatar
Michael Yang committed
1227
1228

		url = resp.Header.Get("Location")
1229
		if completed >= int64(layer.Size) {
Michael Yang's avatar
Michael Yang committed
1230
			break
1231
		}
Michael Yang's avatar
Michael Yang committed
1232
	}
1233

1234
	url = fmt.Sprintf("%s&digest=%s", url, layer.Digest)
1235

Michael Yang's avatar
Michael Yang committed
1236
1237
1238
	headers := make(http.Header)
	headers.Set("Content-Type", "application/octet-stream")
	headers.Set("Content-Length", "0")
1239

1240
	// finish the upload
Michael Yang's avatar
Michael Yang committed
1241
	resp, err := makeRequest(ctx, "PUT", url, headers, nil, regOpts)
1242
1243
1244
1245
1246
1247
1248
1249
1250
	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))
1251
	}
1252
1253
1254
	return nil
}

Michael Yang's avatar
Michael Yang committed
1255
func makeRequestWithRetry(ctx context.Context, method, url string, headers http.Header, body io.ReadSeeker, regOpts *RegistryOptions) (*http.Response, error) {
Michael Yang's avatar
Michael Yang committed
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
	var status string
	for try := 0; try < MaxRetries; try++ {
		resp, err := makeRequest(ctx, method, url, headers, body, regOpts)
		if err != nil {
			log.Printf("couldn't start upload: %v", err)
			return nil, err
		}

		status = resp.Status

		switch resp.StatusCode {
		case http.StatusAccepted, http.StatusCreated:
			return resp, nil
		case http.StatusUnauthorized:
			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
		default:
			body, _ := io.ReadAll(resp.Body)
			return nil, fmt.Errorf("on upload registry responded with code %d: %s", resp.StatusCode, body)
		}
	}

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

Michael Yang's avatar
Michael Yang committed
1294
func makeRequest(ctx context.Context, method, url string, headers http.Header, body io.Reader, regOpts *RegistryOptions) (*http.Response, error) {
1295
1296
1297
1298
1299
1300
1301
1302
	if !strings.HasPrefix(url, "http") {
		if regOpts.Insecure {
			url = "http://" + url
		} else {
			url = "https://" + url
		}
	}

Michael Yang's avatar
Michael Yang committed
1303
	req, err := http.NewRequestWithContext(ctx, method, url, body)
1304
1305
1306
1307
	if err != nil {
		return nil, err
	}

Michael Yang's avatar
Michael Yang committed
1308
1309
1310
1311
	if headers != nil {
		req.Header = headers
	}

Patrick Devine's avatar
Patrick Devine committed
1312
1313
1314
1315
	if regOpts.Token != "" {
		req.Header.Set("Authorization", "Bearer "+regOpts.Token)
	} else if regOpts.Username != "" && regOpts.Password != "" {
		req.SetBasicAuth(regOpts.Username, regOpts.Password)
1316
1317
	}

Michael Yang's avatar
Michael Yang committed
1318
	req.Header.Set("User-Agent", fmt.Sprintf("ollama/%s (%s %s) Go/%s", version.Version, runtime.GOARCH, runtime.GOOS, runtime.Version()))
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328

	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
1329

1330
1331
1332
1333
1334
1335
1336
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}

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

Patrick Devine's avatar
Patrick Devine committed
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
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"),
	}
}

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

Michael Yang's avatar
Michael Yang committed
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
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 {
1387
		return fmt.Errorf("%w: want %s, got %s", errDigestMismatch, digest, fileDigest)
Michael Yang's avatar
Michael Yang committed
1388
1389
1390
1391
	}

	return nil
}