images.go 26.5 KB
Newer Older
1
2
3
4
package server

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

25
	"github.com/ollama/ollama/api"
26
	"github.com/ollama/ollama/auth"
Michael Yang's avatar
Michael Yang committed
27
	"github.com/ollama/ollama/format"
28
	"github.com/ollama/ollama/llm"
29
	"github.com/ollama/ollama/parser"
30
	"github.com/ollama/ollama/envconfig"
31
	"github.com/ollama/ollama/types/errtypes"
Michael Yang's avatar
Michael Yang committed
32
	"github.com/ollama/ollama/types/model"
33
	"github.com/ollama/ollama/version"
34
35
)

Michael Yang's avatar
Michael Yang committed
36
37
38
39
40
41
42
type registryOptions struct {
	Insecure bool
	Username string
	Password string
	Token    string
}

43
type Model struct {
Michael Yang's avatar
Michael Yang committed
44
	Name           string `json:"name"`
45
	Config         ConfigV2
Michael Yang's avatar
Michael Yang committed
46
47
	ShortName      string
	ModelPath      string
48
	ParentModel    string
Michael Yang's avatar
Michael Yang committed
49
50
51
52
53
54
55
	AdapterPaths   []string
	ProjectorPaths []string
	Template       string
	System         string
	License        []string
	Digest         string
	Options        map[string]interface{}
56
57
58
	Messages       []Message
}

59
60
61
62
func (m *Model) IsEmbedding() bool {
	return slices.Contains(m.Config.ModelFamilies, "bert") || slices.Contains(m.Config.ModelFamilies, "nomic-bert")
}

Michael Yang's avatar
Michael Yang committed
63
func (m *Model) String() string {
64
	var modelfile parser.File
Michael Yang's avatar
Michael Yang committed
65

66
	modelfile.Commands = append(modelfile.Commands, parser.Command{
Michael Yang's avatar
Michael Yang committed
67
68
69
		Name: "model",
		Args: m.ModelPath,
	})
70

Michael Yang's avatar
Michael Yang committed
71
	for _, adapter := range m.AdapterPaths {
72
		modelfile.Commands = append(modelfile.Commands, parser.Command{
Michael Yang's avatar
Michael Yang committed
73
74
			Name: "adapter",
			Args: adapter,
Michael Yang's avatar
Michael Yang committed
75
		})
76
77
	}

Michael Yang's avatar
Michael Yang committed
78
	for _, projector := range m.ProjectorPaths {
79
		modelfile.Commands = append(modelfile.Commands, parser.Command{
Michael Yang's avatar
Michael Yang committed
80
81
			Name: "model",
			Args: projector,
Michael Yang's avatar
Michael Yang committed
82
		})
83
84
	}

Michael Yang's avatar
Michael Yang committed
85
	if m.Template != "" {
86
		modelfile.Commands = append(modelfile.Commands, parser.Command{
Michael Yang's avatar
Michael Yang committed
87
88
			Name: "template",
			Args: m.Template,
Michael Yang's avatar
Michael Yang committed
89
		})
90
91
	}

Michael Yang's avatar
Michael Yang committed
92
	if m.System != "" {
93
		modelfile.Commands = append(modelfile.Commands, parser.Command{
Michael Yang's avatar
Michael Yang committed
94
95
			Name: "system",
			Args: m.System,
Michael Yang's avatar
Michael Yang committed
96
		})
97
98
99
100
101
102
	}

	for k, v := range m.Options {
		switch v := v.(type) {
		case []any:
			for _, s := range v {
103
				modelfile.Commands = append(modelfile.Commands, parser.Command{
Michael Yang's avatar
Michael Yang committed
104
105
106
					Name: k,
					Args: fmt.Sprintf("%v", s),
				})
107
108
			}
		default:
109
			modelfile.Commands = append(modelfile.Commands, parser.Command{
Michael Yang's avatar
Michael Yang committed
110
111
112
				Name: k,
				Args: fmt.Sprintf("%v", v),
			})
113
114
115
116
		}
	}

	for _, license := range m.License {
117
		modelfile.Commands = append(modelfile.Commands, parser.Command{
Michael Yang's avatar
Michael Yang committed
118
119
120
			Name: "license",
			Args: license,
		})
121
122
123
	}

	for _, msg := range m.Messages {
124
		modelfile.Commands = append(modelfile.Commands, parser.Command{
Michael Yang's avatar
Michael Yang committed
125
126
127
			Name: "message",
			Args: fmt.Sprintf("%s %s", msg.Role, msg.Content),
		})
128
129
	}

Michael Yang's avatar
Michael Yang committed
130
	return modelfile.String()
131
132
}

133
134
135
type Message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
136
137
138
139
140
}

type ManifestV2 struct {
	SchemaVersion int      `json:"schemaVersion"`
	MediaType     string   `json:"mediaType"`
Michael Yang's avatar
Michael Yang committed
141
	Config        *Layer   `json:"config"`
142
143
144
145
	Layers        []*Layer `json:"layers"`
}

type ConfigV2 struct {
146
147
148
149
150
151
	ModelFormat   string   `json:"model_format"`
	ModelFamily   string   `json:"model_family"`
	ModelFamilies []string `json:"model_families"`
	ModelType     string   `json:"model_type"`
	FileType      string   `json:"file_type"`

152
	// required by spec
153
154
	Architecture string `json:"architecture"`
	OS           string `json:"os"`
155
	RootFS       RootFS `json:"rootfs"`
156
157
158
159
160
161
162
}

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

Patrick Devine's avatar
Patrick Devine committed
163
func GetManifest(mp ModelPath) (*ManifestV2, string, error) {
164
	fp, err := mp.GetManifestPath()
165
	if err != nil {
Patrick Devine's avatar
Patrick Devine committed
166
		return nil, "", err
167
	}
168

169
	if _, err = os.Stat(fp); err != nil {
Patrick Devine's avatar
Patrick Devine committed
170
		return nil, "", err
171
172
173
174
	}

	var manifest *ManifestV2

175
	bts, err := os.ReadFile(fp)
176
	if err != nil {
Patrick Devine's avatar
Patrick Devine committed
177
		return nil, "", fmt.Errorf("couldn't open file '%s'", fp)
178
179
	}

Patrick Devine's avatar
Patrick Devine committed
180
181
182
	shaSum := sha256.Sum256(bts)
	shaStr := hex.EncodeToString(shaSum[:])

183
	if err := json.Unmarshal(bts, &manifest); err != nil {
Patrick Devine's avatar
Patrick Devine committed
184
		return nil, "", err
185
186
	}

Patrick Devine's avatar
Patrick Devine committed
187
	return manifest, shaStr, nil
188
189
190
}

func GetModel(name string) (*Model, error) {
191
	mp := ParseModelPath(name)
Patrick Devine's avatar
Patrick Devine committed
192
	manifest, digest, err := GetManifest(mp)
193
194
195
196
197
	if err != nil {
		return nil, err
	}

	model := &Model{
198
199
200
201
202
		Name:      mp.GetFullTagname(),
		ShortName: mp.GetShortTagname(),
		Digest:    digest,
		Template:  "{{ .Prompt }}",
		License:   []string{},
203
204
	}

205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
	filename, err := GetBlobsPath(manifest.Config.Digest)
	if err != nil {
		return nil, err
	}

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

	if err := json.NewDecoder(configFile).Decode(&model.Config); err != nil {
		return nil, err
	}

220
	for _, layer := range manifest.Layers {
Patrick Devine's avatar
Patrick Devine committed
221
		filename, err := GetBlobsPath(layer.Digest)
222
223
224
225
		if err != nil {
			return nil, err
		}

226
227
228
		switch layer.MediaType {
		case "application/vnd.ollama.image.model":
			model.ModelPath = filename
229
			model.ParentModel = layer.From
230
		case "application/vnd.ollama.image.embed":
231
232
			// Deprecated in versions  > 0.1.2
			// TODO: remove this warning in a future version
233
			slog.Info("WARNING: model contains embeddings, but embeddings in modelfiles have been deprecated and will be ignored.")
234
235
		case "application/vnd.ollama.image.adapter":
			model.AdapterPaths = append(model.AdapterPaths, filename)
Michael Yang's avatar
Michael Yang committed
236
237
		case "application/vnd.ollama.image.projector":
			model.ProjectorPaths = append(model.ProjectorPaths, filename)
238
239
240
241
242
243
244
245
246
		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)
247
248
249
			if err != nil {
				return nil, err
			}
250
251

			model.System = string(bts)
252
253
254
255
256
257
258
		case "application/vnd.ollama.image.prompt":
			bts, err := os.ReadFile(filename)
			if err != nil {
				return nil, err
			}

			model.Template = string(bts)
259
		case "application/vnd.ollama.image.params":
Michael Yang's avatar
Michael Yang committed
260
261
262
263
264
			params, err := os.Open(filename)
			if err != nil {
				return nil, err
			}
			defer params.Close()
265

266
			// parse model options parameters into a map so that we can see which fields have been specified explicitly
267
			if err = json.NewDecoder(params).Decode(&model.Options); err != nil {
268
269
				return nil, err
			}
270
271
272
273
274
275
276
277
278
279
		case "application/vnd.ollama.image.messages":
			msgs, err := os.Open(filename)
			if err != nil {
				return nil, err
			}
			defer msgs.Close()

			if err = json.NewDecoder(msgs).Decode(&model.Messages); err != nil {
				return nil, err
			}
Patrick Devine's avatar
Patrick Devine committed
280
281
282
283
284
285
		case "application/vnd.ollama.image.license":
			bts, err := os.ReadFile(filename)
			if err != nil {
				return nil, err
			}
			model.License = append(model.License, string(bts))
286
287
288
289
290
291
		}
	}

	return model, nil
}

Michael Yang's avatar
Michael Yang committed
292
func realpath(rel, from string) string {
293
	abspath, err := filepath.Abs(from)
Michael Yang's avatar
Michael Yang committed
294
	if err != nil {
295
		return from
296
297
	}

Michael Yang's avatar
Michael Yang committed
298
	home, err := os.UserHomeDir()
299
	if err != nil {
Michael Yang's avatar
Michael Yang committed
300
		return abspath
301
302
	}

303
	if from == "~" {
Michael Yang's avatar
Michael Yang committed
304
		return home
305
306
307
308
	} else if strings.HasPrefix(from, "~/") {
		return filepath.Join(home, from[2:])
	}

Michael Yang's avatar
Michael Yang committed
309
	if _, err := os.Stat(filepath.Join(rel, from)); err == nil {
310
		// this is a file relative to the Modelfile
Michael Yang's avatar
Michael Yang committed
311
		return filepath.Join(rel, from)
312
313
	}

Michael Yang's avatar
Michael Yang committed
314
315
316
	return abspath
}

317
func CreateModel(ctx context.Context, name, modelFileDir, quantization string, modelfile *parser.File, fn func(resp api.ProgressResponse)) (err error) {
318
319
	config := ConfigV2{
		OS:           "linux",
Michael Yang's avatar
Michael Yang committed
320
		Architecture: "amd64",
Michael Yang's avatar
Michael Yang committed
321
322
323
		RootFS: RootFS{
			Type: "layers",
		},
324
325
	}

Michael Yang's avatar
Michael Yang committed
326
327
	var messages []*api.Message
	parameters := make(map[string]any)
Michael Yang's avatar
Michael Yang committed
328

Michael Yang's avatar
Michael Yang committed
329
	var layers []*Layer
Michael Yang's avatar
Michael Yang committed
330
	for _, c := range modelfile.Commands {
Michael Yang's avatar
Michael Yang committed
331
332
		mediatype := fmt.Sprintf("application/vnd.ollama.image.%s", c.Name)

333
		switch c.Name {
Michael Yang's avatar
Michael Yang committed
334
		case "model", "adapter":
Michael Yang's avatar
Michael Yang committed
335
			var baseLayers []*layerWithGGML
Michael Yang's avatar
rebase  
Michael Yang committed
336
			if name := model.ParseName(c.Args); name.IsValid() {
Michael Yang's avatar
Michael Yang committed
337
				baseLayers, err = parseFromModel(ctx, name, fn)
Michael Yang's avatar
Michael Yang committed
338
339
340
				if err != nil {
					return err
				}
Michael Yang's avatar
Michael Yang committed
341
			} else if strings.HasPrefix(c.Args, "@") {
342
				digest := strings.TrimPrefix(c.Args, "@")
Michael Yang's avatar
Michael Yang committed
343
344
				if ib, ok := intermediateBlobs[digest]; ok {
					p, err := GetBlobsPath(ib)
345
346
347
348
349
350
351
352
353
					if err != nil {
						return err
					}

					if _, err := os.Stat(p); errors.Is(err, os.ErrNotExist) {
						// pass
					} else if err != nil {
						return err
					} else {
Michael Yang's avatar
Michael Yang committed
354
355
						fn(api.ProgressResponse{Status: fmt.Sprintf("using cached layer %s", ib)})
						digest = ib
356
357
358
359
					}
				}

				blobpath, err := GetBlobsPath(digest)
Michael Yang's avatar
Michael Yang committed
360
				if err != nil {
Michael Yang's avatar
Michael Yang committed
361
					return err
362
				}
363

Michael Yang's avatar
Michael Yang committed
364
				blob, err := os.Open(blobpath)
Michael Yang's avatar
Michael Yang committed
365
366
367
				if err != nil {
					return err
				}
Michael Yang's avatar
Michael Yang committed
368
				defer blob.Close()
Michael Yang's avatar
Michael Yang committed
369

370
				baseLayers, err = parseFromFile(ctx, blob, digest, fn)
Michael Yang's avatar
Michael Yang committed
371
372
373
				if err != nil {
					return err
				}
Michael Yang's avatar
Michael Yang committed
374
375
			} else if file, err := os.Open(realpath(modelFileDir, c.Args)); err == nil {
				defer file.Close()
Michael Yang's avatar
Michael Yang committed
376

377
				baseLayers, err = parseFromFile(ctx, file, "", fn)
Michael Yang's avatar
Michael Yang committed
378
				if err != nil {
Michael Yang's avatar
Michael Yang committed
379
380
					return err
				}
Michael Yang's avatar
Michael Yang committed
381
382
383
			} else {
				return fmt.Errorf("invalid model reference: %s", c.Args)
			}
Michael Yang's avatar
Michael Yang committed
384

Michael Yang's avatar
Michael Yang committed
385
			for _, baseLayer := range baseLayers {
Michael Yang's avatar
Michael Yang committed
386
387
388
389
				if quantization != "" &&
					baseLayer.MediaType == "application/vnd.ollama.image.model" &&
					baseLayer.GGML != nil &&
					baseLayer.GGML.Name() == "gguf" {
Michael Yang's avatar
Michael Yang committed
390
					want, err := llm.ParseFileType(quantization)
391
					if err != nil {
Michael Yang's avatar
Michael Yang committed
392
						return err
393
					}
Michael Yang's avatar
Michael Yang committed
394

Michael Yang's avatar
Michael Yang committed
395
396
					ft := baseLayer.GGML.KV().FileType()
					if !slices.Contains([]string{"F16", "F32"}, ft.String()) {
Michael Yang's avatar
Michael Yang committed
397
						return errors.New("quantization is only supported for F16 and F32 models")
Michael Yang's avatar
Michael Yang committed
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
					} else if want != ft {
						fn(api.ProgressResponse{Status: fmt.Sprintf("quantizing %s model to %s", ft, quantization)})

						blob, err := GetBlobsPath(baseLayer.Digest)
						if err != nil {
							return err
						}

						temp, err := os.CreateTemp(filepath.Dir(blob), quantization)
						if err != nil {
							return err
						}
						defer temp.Close()
						defer os.Remove(temp.Name())

						if err := llm.Quantize(blob, temp.Name(), want); err != nil {
							return err
						}

Michael Yang's avatar
Michael Yang committed
417
						layers, err := parseFromFile(ctx, temp, "", fn)
Michael Yang's avatar
Michael Yang committed
418
419
420
						if err != nil {
							return err
						}
Michael Yang's avatar
Michael Yang committed
421
422
423
424
425
426
427

						if len(layers) != 1 {
							return errors.New("quantization failed")
						}

						baseLayer.Layer = layers[0].Layer
						baseLayer.GGML = layers[0].GGML
Michael Yang's avatar
Michael Yang committed
428
					}
429
				}
430

Michael Yang's avatar
Michael Yang committed
431
432
433
434
				if baseLayer.GGML != nil {
					config.ModelFormat = cmp.Or(config.ModelFormat, baseLayer.GGML.Name())
					config.ModelFamily = cmp.Or(config.ModelFamily, baseLayer.GGML.KV().Architecture())
					config.ModelType = cmp.Or(config.ModelType, format.HumanNumber(baseLayer.GGML.KV().ParameterCount()))
Michael Yang's avatar
Michael Yang committed
435
					config.FileType = cmp.Or(config.FileType, baseLayer.GGML.KV().FileType().String())
Michael Yang's avatar
Michael Yang committed
436
					config.ModelFamilies = append(config.ModelFamilies, baseLayer.GGML.KV().Architecture())
437
438
				}

Michael Yang's avatar
Michael Yang committed
439
				layers = append(layers, baseLayer.Layer)
440
			}
Michael Yang's avatar
Michael Yang committed
441
442
443
		case "license", "template", "system":
			blob := strings.NewReader(c.Args)
			layer, err := NewLayer(blob, mediatype)
444
			if err != nil {
Michael Yang's avatar
Michael Yang committed
445
				return err
446
447
			}

Michael Yang's avatar
Michael Yang committed
448
449
450
451
452
			if c.Name != "license" {
				// replace
				layers = slices.DeleteFunc(layers, func(layer *Layer) bool {
					return layer.MediaType == mediatype
				})
Michael Yang's avatar
Michael Yang committed
453
454
			}

Michael Yang's avatar
Michael Yang committed
455
456
457
458
459
460
461
462
463
464
			layers = append(layers, layer)
		case "message":
			role, content, ok := strings.Cut(c.Args, ": ")
			if !ok {
				return fmt.Errorf("invalid message: %s", c.Args)
			}

			messages = append(messages, &api.Message{Role: role, Content: content})
		default:
			ps, err := api.FormatParams(map[string][]string{c.Name: {c.Args}})
465
			if err != nil {
Michael Yang's avatar
Michael Yang committed
466
				return err
467
			}
Bruce MacDonald's avatar
Bruce MacDonald committed
468

Michael Yang's avatar
Michael Yang committed
469
470
471
472
473
474
475
476
477
478
479
			for k, v := range ps {
				if ks, ok := parameters[k].([]string); ok {
					parameters[k] = append(ks, v.([]string)...)
				} else if vs, ok := v.([]string); ok {
					parameters[k] = vs
				} else {
					parameters[k] = v
				}
			}
		}
	}
Michael Yang's avatar
Michael Yang committed
480

Michael Yang's avatar
Michael Yang committed
481
482
483
484
485
486
487
488
489
490
491
492
493
	var err2 error
	layers = slices.DeleteFunc(layers, func(layer *Layer) bool {
		switch layer.MediaType {
		case "application/vnd.ollama.image.message":
			// if there are new messages, remove the inherited ones
			if len(messages) > 0 {
				return true
			}

			return false
		case "application/vnd.ollama.image.params":
			// merge inherited parameters with new ones
			r, err := layer.Open()
Bruce MacDonald's avatar
Bruce MacDonald committed
494
			if err != nil {
Michael Yang's avatar
Michael Yang committed
495
496
				err2 = err
				return false
Bruce MacDonald's avatar
Bruce MacDonald committed
497
			}
Michael Yang's avatar
Michael Yang committed
498
			defer r.Close()
Bruce MacDonald's avatar
Bruce MacDonald committed
499

Michael Yang's avatar
Michael Yang committed
500
501
502
503
504
			var ps map[string]any
			if err := json.NewDecoder(r).Decode(&ps); err != nil {
				err2 = err
				return false
			}
Michael Yang's avatar
Michael Yang committed
505

Michael Yang's avatar
Michael Yang committed
506
507
508
509
			for k, v := range ps {
				if _, ok := parameters[k]; !ok {
					parameters[k] = v
				}
510
			}
511

Michael Yang's avatar
Michael Yang committed
512
			return true
513
		default:
Michael Yang's avatar
Michael Yang committed
514
			return false
515
		}
Michael Yang's avatar
Michael Yang committed
516
517
518
519
	})

	if err2 != nil {
		return err2
520
521
	}

522
523
	if len(messages) > 0 {
		var b bytes.Buffer
Michael Yang's avatar
Michael Yang committed
524
		if err := json.NewEncoder(&b).Encode(messages); err != nil {
525
526
527
528
529
530
531
532
			return err
		}

		layer, err := NewLayer(&b, "application/vnd.ollama.image.messages")
		if err != nil {
			return err
		}

Michael Yang's avatar
Michael Yang committed
533
		layers = append(layers, layer)
534
535
	}

Michael Yang's avatar
Michael Yang committed
536
	if len(parameters) > 0 {
Michael Yang's avatar
Michael Yang committed
537
		var b bytes.Buffer
Michael Yang's avatar
Michael Yang committed
538
		if err := json.NewEncoder(&b).Encode(parameters); err != nil {
539
540
541
			return err
		}

Michael Yang's avatar
Michael Yang committed
542
		layer, err := NewLayer(&b, "application/vnd.ollama.image.params")
543
		if err != nil {
Michael Yang's avatar
Michael Yang committed
544
			return err
545
		}
Michael Yang's avatar
Michael Yang committed
546

Michael Yang's avatar
Michael Yang committed
547
		layers = append(layers, layer)
548
549
	}

Michael Yang's avatar
Michael Yang committed
550
551
	digests := make([]string, len(layers))
	for i, layer := range layers {
Michael Yang's avatar
Michael Yang committed
552
		digests[i] = layer.Digest
553
554
	}

Michael Yang's avatar
Michael Yang committed
555
	config.RootFS.DiffIDs = digests
Michael Yang's avatar
Michael Yang committed
556

Michael Yang's avatar
Michael Yang committed
557
558
	var b bytes.Buffer
	if err := json.NewEncoder(&b).Encode(config); err != nil {
559
560
561
		return err
	}

Michael Yang's avatar
Michael Yang committed
562
	layer, err := NewLayer(&b, "application/vnd.docker.container.image.v1+json")
Michael Yang's avatar
Michael Yang committed
563
	if err != nil {
564
565
566
		return err
	}

Michael Yang's avatar
Michael Yang committed
567
568
569
	for _, layer := range append(layers, layer) {
		if layer.status != "" {
			fn(api.ProgressResponse{Status: layer.status})
570
		}
Michael Yang's avatar
Michael Yang committed
571
	}
572

Michael Yang's avatar
Michael Yang committed
573
574
575
576
577
578
	unref := make(map[string]struct{})
	if manifest, _, err := GetManifest(ParseModelPath(name)); err == nil {
		for _, layer := range manifest.Layers {
			if !slices.Contains(digests, layer.Digest) {
				unref[layer.Digest] = struct{}{}
			}
579
580
		}

Michael Yang's avatar
Michael Yang committed
581
582
583
		if manifest.Config.Digest != layer.Digest {
			unref[manifest.Config.Digest] = struct{}{}
		}
584
585
	}

Michael Yang's avatar
Michael Yang committed
586
	fn(api.ProgressResponse{Status: "writing manifest"})
Michael Yang's avatar
Michael Yang committed
587
	if err := WriteManifest(name, layer, layers); err != nil {
588
589
		return err
	}
590

591
	if !envconfig.NoPrune {
592
		if err := deleteUnusedLayers(nil, unref); err != nil {
Michael Yang's avatar
Michael Yang committed
593
			return err
594
595
596
		}
	}

Michael Yang's avatar
Michael Yang committed
597
598
	fn(api.ProgressResponse{Status: "success"})
	return nil
599
600
}

Michael Yang's avatar
Michael Yang committed
601
func CopyModel(src, dst model.Name) error {
602
603
604
605
606
607
608
	if !dst.IsFullyQualified() {
		return model.Unqualified(dst)
	}
	if !src.IsFullyQualified() {
		return model.Unqualified(src)
	}

609
610
611
612
	if src.Filepath() == dst.Filepath() {
		return nil
	}

Michael Yang's avatar
Michael Yang committed
613
	manifests, err := GetManifestPath()
614
615
616
617
	if err != nil {
		return err
	}

618
	dstpath := filepath.Join(manifests, dst.Filepath())
Michael Yang's avatar
Michael Yang committed
619
	if err := os.MkdirAll(filepath.Dir(dstpath), 0o755); err != nil {
620
621
		return err
	}
Patrick Devine's avatar
Patrick Devine committed
622

623
	srcpath := filepath.Join(manifests, src.Filepath())
Michael Yang's avatar
Michael Yang committed
624
	srcfile, err := os.Open(srcpath)
Patrick Devine's avatar
Patrick Devine committed
625
626
627
	if err != nil {
		return err
	}
Michael Yang's avatar
Michael Yang committed
628
	defer srcfile.Close()
Patrick Devine's avatar
Patrick Devine committed
629

Michael Yang's avatar
Michael Yang committed
630
	dstfile, err := os.Create(dstpath)
Patrick Devine's avatar
Patrick Devine committed
631
632
633
	if err != nil {
		return err
	}
Michael Yang's avatar
Michael Yang committed
634
	defer dstfile.Close()
Patrick Devine's avatar
Patrick Devine committed
635

Michael Yang's avatar
Michael Yang committed
636
637
	_, err = io.Copy(dstfile, srcfile)
	return err
Patrick Devine's avatar
Patrick Devine committed
638
639
}

640
func deleteUnusedLayers(skipModelPath *ModelPath, deleteMap map[string]struct{}) error {
641
642
643
644
	fp, err := GetManifestPath()
	if err != nil {
		return err
	}
Michael Yang's avatar
Michael Yang committed
645
646
647
648

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

Michael Yang's avatar
Michael Yang committed
651
652
653
654
		dir, file := filepath.Split(path)
		dir = strings.Trim(strings.TrimPrefix(dir, fp), string(os.PathSeparator))
		tag := strings.Join([]string{dir, file}, ":")
		fmp := ParseModelPath(tag)
655

Michael Yang's avatar
Michael Yang committed
656
		// skip the manifest we're trying to delete
657
		if skipModelPath != nil && skipModelPath.GetFullTagname() == fmp.GetFullTagname() {
Michael Yang's avatar
Michael Yang committed
658
			return nil
659
		}
Michael Yang's avatar
Michael Yang committed
660
661
662
663

		// save (i.e. delete from the deleteMap) any files used in other manifests
		manifest, _, err := GetManifest(fmp)
		if err != nil {
Michael Yang's avatar
Michael Yang committed
664
			//nolint:nilerr
Michael Yang's avatar
Michael Yang committed
665
666
667
668
669
670
671
672
			return nil
		}

		for _, layer := range manifest.Layers {
			delete(deleteMap, layer.Digest)
		}

		delete(deleteMap, manifest.Config.Digest)
673
		return nil
Michael Yang's avatar
Michael Yang committed
674
675
676
	}

	if err := filepath.Walk(fp, walkFunc); err != nil {
Michael Yang's avatar
Michael Yang committed
677
678
		return err
	}
679
680

	// only delete the files which are still in the deleteMap
Michael Yang's avatar
Michael Yang committed
681
682
683
	for k := range deleteMap {
		fp, err := GetBlobsPath(k)
		if err != nil {
684
			slog.Info(fmt.Sprintf("couldn't get file path for '%s': %v", k, err))
Michael Yang's avatar
Michael Yang committed
685
686
			continue
		}
687
688
689
		if err := os.Remove(fp); err != nil {
			slog.Info(fmt.Sprintf("couldn't remove file '%s': %v", fp, err))
			continue
690
691
692
		}
	}

693
694
695
696
	return nil
}

func PruneLayers() error {
Michael Yang's avatar
Michael Yang committed
697
	deleteMap := make(map[string]struct{})
698
699
700
701
702
703
704
	p, err := GetBlobsPath("")
	if err != nil {
		return err
	}

	blobs, err := os.ReadDir(p)
	if err != nil {
705
		slog.Info(fmt.Sprintf("couldn't read dir '%s': %v", p, err))
706
707
708
709
710
		return err
	}

	for _, blob := range blobs {
		name := blob.Name()
711
		name = strings.ReplaceAll(name, "-", ":")
712
713
714
715
716
717
718
719
720
721
722

		_, err := GetBlobsPath(name)
		if err != nil {
			if errors.Is(err, ErrInvalidDigestFormat) {
				// remove invalid blobs (e.g. partial downloads)
				if err := os.Remove(filepath.Join(p, blob.Name())); err != nil {
					slog.Error("couldn't remove blob", "blob", blob.Name(), "error", err)
				}
			}

			continue
Michael Yang's avatar
Michael Yang committed
723
		}
724
725

		deleteMap[name] = struct{}{}
726
727
	}

728
	slog.Info(fmt.Sprintf("total blobs: %d", len(deleteMap)))
729

730
	err = deleteUnusedLayers(nil, deleteMap)
731
732
733
734
	if err != nil {
		return err
	}

735
	slog.Info(fmt.Sprintf("total unused blobs removed: %d", len(deleteMap)))
736
737
738
739

	return nil
}

Michael Yang's avatar
Michael Yang committed
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
func PruneDirectory(path string) error {
	info, err := os.Lstat(path)
	if err != nil {
		return err
	}

	if info.IsDir() && info.Mode()&os.ModeSymlink == 0 {
		entries, err := os.ReadDir(path)
		if err != nil {
			return err
		}

		for _, entry := range entries {
			if err := PruneDirectory(filepath.Join(path, entry.Name())); err != nil {
				return err
			}
		}

		entries, err = os.ReadDir(path)
		if err != nil {
			return err
		}

		if len(entries) > 0 {
			return nil
		}

		return os.Remove(path)
	}

	return nil
}

Michael Yang's avatar
Michael Yang committed
773
func PushModel(ctx context.Context, name string, regOpts *registryOptions, fn func(api.ProgressResponse)) error {
774
	mp := ParseModelPath(name)
775
776
	fn(api.ProgressResponse{Status: "retrieving manifest"})

777
778
779
780
	if mp.ProtocolScheme == "http" && !regOpts.Insecure {
		return fmt.Errorf("insecure protocol http")
	}

Patrick Devine's avatar
Patrick Devine committed
781
	manifest, _, err := GetManifest(mp)
782
	if err != nil {
783
		fn(api.ProgressResponse{Status: "couldn't retrieve manifest"})
784
785
786
787
		return err
	}

	var layers []*Layer
Jeffrey Morgan's avatar
Jeffrey Morgan committed
788
	layers = append(layers, manifest.Layers...)
Michael Yang's avatar
Michael Yang committed
789
	layers = append(layers, manifest.Config)
790
791

	for _, layer := range layers {
Michael Yang's avatar
Michael Yang committed
792
		if err := uploadBlob(ctx, mp, layer, regOpts, fn); err != nil {
793
			slog.Info(fmt.Sprintf("error uploading blob: %v", err))
794
795
			return err
		}
796
797
	}

798
	fn(api.ProgressResponse{Status: "pushing manifest"})
Michael Yang's avatar
Michael Yang committed
799
800
	requestURL := mp.BaseURL()
	requestURL = requestURL.JoinPath("v2", mp.GetNamespaceRepository(), "manifests", mp.Tag)
801
802
803
804
805
806

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

Michael Yang's avatar
Michael Yang committed
807
808
	headers := make(http.Header)
	headers.Set("Content-Type", "application/vnd.docker.distribution.manifest.v2+json")
Michael Yang's avatar
Michael Yang committed
809
	resp, err := makeRequestWithRetry(ctx, http.MethodPut, requestURL, headers, bytes.NewReader(manifestJSON), regOpts)
810
811
812
813
814
	if err != nil {
		return err
	}
	defer resp.Body.Close()

815
	fn(api.ProgressResponse{Status: "success"})
816
817
818
819

	return nil
}

Michael Yang's avatar
Michael Yang committed
820
func PullModel(ctx context.Context, name string, regOpts *registryOptions, fn func(api.ProgressResponse)) error {
821
822
	mp := ParseModelPath(name)

823
824
825
826
827
	var manifest *ManifestV2
	var err error
	var noprune string

	// build deleteMap to prune unused layers
Michael Yang's avatar
Michael Yang committed
828
	deleteMap := make(map[string]struct{})
829

830
	if !envconfig.NoPrune {
831
832
833
834
835
836
837
		manifest, _, err = GetManifest(mp)
		if err != nil && !errors.Is(err, os.ErrNotExist) {
			return err
		}

		if manifest != nil {
			for _, l := range manifest.Layers {
Michael Yang's avatar
Michael Yang committed
838
				deleteMap[l.Digest] = struct{}{}
839
			}
Michael Yang's avatar
Michael Yang committed
840
			deleteMap[manifest.Config.Digest] = struct{}{}
841
842
843
		}
	}

844
845
	if mp.ProtocolScheme == "http" && !regOpts.Insecure {
		return fmt.Errorf("insecure protocol http")
846
	}
847

848
	fn(api.ProgressResponse{Status: "pulling manifest"})
849

850
	manifest, err = pullModelManifest(ctx, mp, regOpts)
851
	if err != nil {
852
		return fmt.Errorf("pull model manifest: %s", err)
853
854
855
	}

	var layers []*Layer
Bruce MacDonald's avatar
Bruce MacDonald committed
856
	layers = append(layers, manifest.Layers...)
Michael Yang's avatar
Michael Yang committed
857
	layers = append(layers, manifest.Config)
858
859

	for _, layer := range layers {
860
861
862
863
864
865
866
867
		if err := downloadBlob(
			ctx,
			downloadOpts{
				mp:      mp,
				digest:  layer.Digest,
				regOpts: regOpts,
				fn:      fn,
			}); err != nil {
868
869
			return err
		}
870
		delete(deleteMap, layer.Digest)
871
	}
872
	delete(deleteMap, manifest.Config.Digest)
873

Michael Yang's avatar
Michael Yang committed
874
875
876
	fn(api.ProgressResponse{Status: "verifying sha256 digest"})
	for _, layer := range layers {
		if err := verifyBlob(layer.Digest); err != nil {
877
878
879
880
881
882
883
884
			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
885
					slog.Info(fmt.Sprintf("couldn't remove file with digest mismatch '%s': %v", fp, err))
886
887
				}
			}
Michael Yang's avatar
Michael Yang committed
888
889
890
891
			return err
		}
	}

892
	fn(api.ProgressResponse{Status: "writing manifest"})
893

894
	manifestJSON, err := json.Marshal(manifest)
895
896
897
898
	if err != nil {
		return err
	}

899
	fp, err := mp.GetManifestPath()
900
901
902
	if err != nil {
		return err
	}
903
904
905
	if err := os.MkdirAll(filepath.Dir(fp), 0o755); err != nil {
		return err
	}
906

Bruce MacDonald's avatar
Bruce MacDonald committed
907
	err = os.WriteFile(fp, manifestJSON, 0o644)
908
	if err != nil {
909
		slog.Info(fmt.Sprintf("couldn't write to %s", fp))
910
911
912
		return err
	}

913
914
	if noprune == "" {
		fn(api.ProgressResponse{Status: "removing any unused layers"})
915
		err = deleteUnusedLayers(nil, deleteMap)
916
917
918
919
920
		if err != nil {
			return err
		}
	}

921
	fn(api.ProgressResponse{Status: "success"})
922
923
924
925

	return nil
}

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

Michael Yang's avatar
Michael Yang committed
929
930
	headers := make(http.Header)
	headers.Set("Accept", "application/vnd.docker.distribution.manifest.v2+json")
Michael Yang's avatar
Michael Yang committed
931
	resp, err := makeRequestWithRetry(ctx, http.MethodGet, requestURL, headers, nil, regOpts)
932
933
934
935
936
937
938
939
940
941
942
943
944
945
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

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

	return m, err
}

// GetSHA256Digest returns the SHA256 hash of a given buffer and returns it, and the size of buffer
Michael Yang's avatar
Michael Yang committed
946
func GetSHA256Digest(r io.Reader) (string, int64) {
Michael Yang's avatar
Michael Yang committed
947
948
949
950
951
952
	h := sha256.New()
	n, err := io.Copy(h, r)
	if err != nil {
		log.Fatal(err)
	}

Michael Yang's avatar
Michael Yang committed
953
	return fmt.Sprintf("sha256:%x", h.Sum(nil)), n
954
955
}

956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
var errUnauthorized = fmt.Errorf("unauthorized: access denied")

// getTokenSubject returns the subject of a JWT token, it does not validate the token
func getTokenSubject(token string) string {
	parts := strings.Split(token, ".")
	if len(parts) != 3 {
		slog.Error("jwt token does not contain 3 parts")
		return ""
	}

	payload := parts[1]
	payloadBytes, err := base64.RawURLEncoding.DecodeString(payload)
	if err != nil {
		slog.Error(fmt.Sprintf("failed to decode jwt payload: %v", err))
		return ""
	}

	var payloadMap map[string]interface{}
	if err := json.Unmarshal(payloadBytes, &payloadMap); err != nil {
		slog.Error(fmt.Sprintf("failed to unmarshal payload JSON: %v", err))
		return ""
	}

	sub, ok := payloadMap["sub"]
	if !ok {
		slog.Error("jwt does not contain 'sub' field")
		return ""
	}

	return fmt.Sprintf("%s", sub)
}
987

Michael Yang's avatar
Michael Yang committed
988
func makeRequestWithRetry(ctx context.Context, method string, requestURL *url.URL, headers http.Header, body io.ReadSeeker, regOpts *registryOptions) (*http.Response, error) {
989
	anonymous := true // access will default to anonymous if no user is found associated with the public key
Michael Yang's avatar
Michael Yang committed
990
	for i := 0; i < 2; i++ {
Michael Yang's avatar
Michael Yang committed
991
		resp, err := makeRequest(ctx, method, requestURL, headers, body, regOpts)
Michael Yang's avatar
Michael Yang committed
992
		if err != nil {
Michael Yang's avatar
Michael Yang committed
993
			if !errors.Is(err, context.Canceled) {
994
				slog.Info(fmt.Sprintf("request failed: %v", err))
Michael Yang's avatar
Michael Yang committed
995
996
			}

Michael Yang's avatar
Michael Yang committed
997
998
			return nil, err
		}
Michael Yang's avatar
Michael Yang committed
999
1000
1001
1002

		switch {
		case resp.StatusCode == http.StatusUnauthorized:
			// Handle authentication error with one retry
Michael Yang's avatar
Michael Yang committed
1003
1004
			challenge := parseRegistryChallenge(resp.Header.Get("www-authenticate"))
			token, err := getAuthorizationToken(ctx, challenge)
Michael Yang's avatar
Michael Yang committed
1005
1006
1007
			if err != nil {
				return nil, err
			}
1008
			anonymous = getTokenSubject(token) == "anonymous"
Michael Yang's avatar
Michael Yang committed
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
			regOpts.Token = token
			if body != nil {
				_, err = body.Seek(0, io.SeekStart)
				if err != nil {
					return nil, err
				}
			}
		case resp.StatusCode == http.StatusNotFound:
			return nil, os.ErrNotExist
		case resp.StatusCode >= http.StatusBadRequest:
			responseBody, err := io.ReadAll(resp.Body)
			if err != nil {
				return nil, fmt.Errorf("%d: %s", resp.StatusCode, err)
			}
			return nil, fmt.Errorf("%d: %s", resp.StatusCode, responseBody)
		default:
			return resp, nil
Michael Yang's avatar
Michael Yang committed
1026
1027
1028
		}
	}

1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
	if anonymous {
		// no user is associated with the public key, and the request requires non-anonymous access
		pubKey, nestedErr := auth.GetPublicKey()
		if nestedErr != nil {
			slog.Error(fmt.Sprintf("couldn't get public key: %v", nestedErr))
			return nil, errUnauthorized
		}
		return nil, &errtypes.UnknownOllamaKey{Key: pubKey}
	}
	// user is associated with the public key, but is not authorized to make the request
Michael Yang's avatar
Michael Yang committed
1039
	return nil, errUnauthorized
Michael Yang's avatar
Michael Yang committed
1040
1041
}

Michael Yang's avatar
Michael Yang committed
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
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 != nil && regOpts.Insecure {
		requestURL.Scheme = "http"
	}

	req, err := http.NewRequestWithContext(ctx, method, requestURL.String(), body)
	if err != nil {
		return nil, err
	}

	if headers != nil {
		req.Header = headers
	}

	if regOpts != nil {
		if regOpts.Token != "" {
			req.Header.Set("Authorization", "Bearer "+regOpts.Token)
		} else if regOpts.Username != "" && regOpts.Password != "" {
			req.SetBasicAuth(regOpts.Username, regOpts.Password)
		}
	}

	req.Header.Set("User-Agent", fmt.Sprintf("ollama/%s (%s %s) Go/%s", version.Version, runtime.GOARCH, runtime.GOOS, runtime.Version()))

	if s := req.Header.Get("Content-Length"); s != "" {
		contentLength, err := strconv.ParseInt(s, 10, 64)
		if err != nil {
			return nil, err
		}

		req.ContentLength = contentLength
	}

Michael Yang's avatar
Michael Yang committed
1075
	resp, err := http.DefaultClient.Do(req)
Michael Yang's avatar
Michael Yang committed
1076
1077
1078
1079
1080
1081
1082
	if err != nil {
		return nil, err
	}

	return resp, nil
}

Patrick Devine's avatar
Patrick Devine committed
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
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]
}

Michael Yang's avatar
Michael Yang committed
1106
func parseRegistryChallenge(authStr string) registryChallenge {
Patrick Devine's avatar
Patrick Devine committed
1107
1108
	authStr = strings.TrimPrefix(authStr, "Bearer ")

Michael Yang's avatar
Michael Yang committed
1109
	return registryChallenge{
Patrick Devine's avatar
Patrick Devine committed
1110
1111
1112
1113
1114
1115
		Realm:   getValue(authStr, "realm"),
		Service: getValue(authStr, "service"),
		Scope:   getValue(authStr, "scope"),
	}
}

1116
var errDigestMismatch = errors.New("digest mismatch, file must be downloaded again")
1117

Michael Yang's avatar
Michael Yang committed
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
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 {
1132
		return fmt.Errorf("%w: want %s, got %s", errDigestMismatch, digest, fileDigest)
Michael Yang's avatar
Michael Yang committed
1133
1134
1135
1136
	}

	return nil
}