1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
package storage
import (
"embed"
"errors"
"fmt"
"io/fs"
"path"
"sort"
"strconv"
"strings"
"github.com/authelia/authelia/v4/internal/model"
)
//go:embed migrations/*
var migrationsFS embed.FS
func latestMigrationVersion(providerName string) (version int, err error) {
var (
entries []fs.DirEntry
migration model.SchemaMigration
)
if entries, err = migrationsFS.ReadDir(path.Join(pathMigrations, providerName)); err != nil {
return -1, err
}
for _, entry := range entries {
if entry.IsDir() {
continue
}
if migration, err = scanMigration(providerName, entry.Name()); err != nil {
return -1, err
}
if !migration.Up {
continue
}
if migration.Version > version {
version = migration.Version
}
}
return version, nil
}
// loadMigrations scans the migrations fs and loads the appropriate migrations for a given providerName, prior and
// target versions. If the target version is -1 this indicates the latest version. If the target version is 0
// this indicates the database zero state.
func loadMigrations(providerName string, prior, target int) (migrations []model.SchemaMigration, err error) {
if prior == target {
return nil, ErrMigrateCurrentVersionSameAsTarget
}
var (
migration model.SchemaMigration
entries []fs.DirEntry
)
if entries, err = migrationsFS.ReadDir(path.Join(pathMigrations, providerName)); err != nil {
return nil, err
}
up := prior < target
for _, entry := range entries {
if entry.IsDir() {
continue
}
if migration, err = scanMigration(providerName, entry.Name()); err != nil {
return nil, err
}
if skipMigration(up, target, prior, &migration) {
continue
}
migrations = append(migrations, migration)
}
if up {
sort.Slice(migrations, func(i, j int) bool {
return migrations[i].Version < migrations[j].Version
})
} else {
sort.Slice(migrations, func(i, j int) bool {
return migrations[i].Version > migrations[j].Version
})
}
return migrations, nil
}
func skipMigration(up bool, target, prior int, migration *model.SchemaMigration) (skip bool) {
if up {
if !migration.Up {
// Skip if we wanted an Up migration but it isn't an Up migration.
return true
}
if migration.Version > target || migration.Version <= prior {
// Skip if the migration version is greater than the target or less than or equal to the previous version.
return true
}
} else {
if migration.Up {
// Skip if we didn't want an Up migration but it is an Up migration.
return true
}
if migration.Version <= target || migration.Version > prior {
// Skip the migration if we want to go down and the migration version is less than or equal to the target
// or greater than the previous version.
return true
}
}
return false
}
func scanMigration(providerName, m string) (migration model.SchemaMigration, err error) {
if !reMigration.MatchString(m) {
return model.SchemaMigration{}, errors.New("invalid migration: could not parse the format")
}
result := reMigration.FindStringSubmatch(m)
migration = model.SchemaMigration{
Name: strings.ReplaceAll(result[reMigration.SubexpIndex("Name")], "_", " "),
Provider: providerName,
}
var data []byte
if data, err = migrationsFS.ReadFile(path.Join(pathMigrations, providerName, m)); err != nil {
return model.SchemaMigration{}, err
}
migration.Query = string(data)
switch direction := result[reMigration.SubexpIndex("Direction")]; direction {
case "up":
migration.Up = true
case "down":
migration.Up = false
default:
return model.SchemaMigration{}, fmt.Errorf("invalid migration: value in Direction group '%s' must be up or down", direction)
}
migration.Version, _ = strconv.Atoi(result[reMigration.SubexpIndex("Version")])
return migration, nil
}
|
