Repository navigation
Expand file tree
/
Copy pathmigrations.go
More file actions
190 lines (167 loc) · 6.1 KB
/
Copy pathmigrations.go
File metadata and controls
190 lines (167 loc) · 6.1 KB
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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
package migrations
import (
"fmt"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/client-go/tools/cache"
v1 "kubevirt.io/api/core/v1"
"kubevirt.io/client-go/log"
"kubevirt.io/kubevirt/pkg/controller"
"kubevirt.io/kubevirt/pkg/pointer"
virtconfig "kubevirt.io/kubevirt/pkg/virt-config"
)
const (
QEMUMaxMigrationDowntimeMS uint64 = 2_000_000
QEMUDefaultTargetDowntimeMS uint64 = 300
QueuePriorityRunning int = 1000
QueuePrioritySystemCritical int = 100
QueuePriorityUserTriggered int = 50
QueuePrioritySystemMaintenance int = 20
QueuePriorityDefault int = 0
)
func ListUnfinishedMigrations(indexer cache.Indexer) []*v1.VirtualMachineInstanceMigration {
objs, err := indexer.ByIndex(controller.UnfinishedIndex, controller.UnfinishedIndex)
if err != nil {
log.Log.Reason(err).Errorf("Failed to use unfinished index")
return nil
}
var migrations []*v1.VirtualMachineInstanceMigration
for _, obj := range objs {
migration := obj.(*v1.VirtualMachineInstanceMigration)
if !migration.IsFinal() {
migrations = append(migrations, migration)
}
}
return migrations
}
func ListWorkloadUpdateMigrations(indexer cache.Indexer, vmiName, ns string) []v1.VirtualMachineInstanceMigration {
objs, err := indexer.ByIndex(controller.ByVMINameIndex, fmt.Sprintf("%s/%s", ns, vmiName))
if err != nil {
log.Log.Reason(err).Errorf("Failed to use byVMIName index for workload migrations")
return nil
}
migrations := []v1.VirtualMachineInstanceMigration{}
for _, obj := range objs {
migration := obj.(*v1.VirtualMachineInstanceMigration)
if migration.IsFinal() {
continue
}
if !metav1.HasAnnotation(migration.ObjectMeta, v1.WorkloadUpdateMigrationAnnotation) {
continue
}
migrations = append(migrations, *migration)
}
return migrations
}
func FilterRunningMigrations(migrations []*v1.VirtualMachineInstanceMigration) []*v1.VirtualMachineInstanceMigration {
runningMigrations := []*v1.VirtualMachineInstanceMigration{}
for _, migration := range migrations {
if migration.IsRunning() {
runningMigrations = append(runningMigrations, migration)
}
}
return runningMigrations
}
// IsMigrating returns true if a given VMI is still migrating and false otherwise.
func IsMigrating(vmi *v1.VirtualMachineInstance) bool {
if vmi == nil {
log.Log.V(4).Infof("checking if VMI is migrating, but it is empty")
return false
}
now := metav1.Now()
running := false
if vmi.Status.MigrationState != nil {
start := vmi.Status.MigrationState.StartTimestamp
stop := vmi.Status.MigrationState.EndTimestamp
if start != nil && (now.After(start.Time) || now.Equal(start)) {
running = true
}
if stop != nil && (now.After(stop.Time) || now.Equal(stop)) {
running = false
}
}
return running
}
func IsBackupInProgress(vmi *v1.VirtualMachineInstance) bool {
if vmi == nil || vmi.Status.ChangedBlockTracking == nil || vmi.Status.ChangedBlockTracking.BackupStatus == nil {
return false
}
backupStatus := vmi.Status.ChangedBlockTracking.BackupStatus
return backupStatus.BackupName != "" && !backupStatus.Completed
}
func MigrationFailed(vmi *v1.VirtualMachineInstance) bool {
if vmi.Status.MigrationState != nil && vmi.Status.MigrationState.Failed {
return true
}
return false
}
func VMIEvictionStrategy(clusterConfig *virtconfig.ClusterConfig, vmi *v1.VirtualMachineInstance) *v1.EvictionStrategy {
if vmi != nil && vmi.Spec.EvictionStrategy != nil {
return vmi.Spec.EvictionStrategy
}
clusterStrategy := clusterConfig.GetConfig().EvictionStrategy
return clusterStrategy
}
func VMIMigratableOnEviction(clusterConfig *virtconfig.ClusterConfig, vmi *v1.VirtualMachineInstance) bool {
strategy := VMIEvictionStrategy(clusterConfig, vmi)
if strategy == nil {
return false
}
switch *strategy {
case v1.EvictionStrategyLiveMigrate:
return true
case v1.EvictionStrategyLiveMigrateIfPossible:
return vmi.IsMigratable()
}
return false
}
func ActiveMigrationExistsForVMI(migrationIndexer cache.Indexer, vmi *v1.VirtualMachineInstance) (bool, error) {
objs, err := migrationIndexer.ByIndex(controller.ByVMINameIndex, fmt.Sprintf("%s/%s", vmi.Namespace, vmi.Name))
if err != nil {
return false, err
}
for _, obj := range objs {
migration := obj.(*v1.VirtualMachineInstanceMigration)
if migration.IsRunning() {
return true, nil
}
}
return false, nil
}
func PriorityFromMigration(migration *v1.VirtualMachineInstanceMigration) *int {
if migration.Spec.Priority == nil {
return pointer.P(QueuePriorityDefault)
}
switch *migration.Spec.Priority {
case v1.PrioritySystemCritical:
return pointer.P(QueuePrioritySystemCritical)
case v1.PriorityUserTriggered:
return pointer.P(QueuePriorityUserTriggered)
case v1.PrioritySystemMaintenance:
return pointer.P(QueuePrioritySystemMaintenance)
default:
return pointer.P(QueuePriorityDefault)
}
}
// ToVMIMConfigurationOptions copies cluster migration defaults into the resolved
// options type carried on VMIM status. cfg must not be nil. The returned value
// owns its pointer fields and is safe to store on VMI status or mutate locally.
func ToVMIMConfigurationOptions(cfg *v1.MigrationConfiguration) *v1.VMIMConfigurationOptions {
opts := &v1.VMIMConfigurationOptions{
AllowAutoConverge: cfg.AllowAutoConverge,
BandwidthPerMigration: cfg.BandwidthPerMigration,
CompletionTimeoutPerGiB: cfg.CompletionTimeoutPerGiB,
MaxDowntimeMs: cfg.MaxDowntimeMs,
ProgressTimeout: cfg.ProgressTimeout,
UtilityVolumesTimeout: cfg.UtilityVolumesTimeout,
UnsafeMigrationOverride: cfg.UnsafeMigrationOverride,
AllowPostCopy: cfg.AllowPostCopy,
AllowWorkloadDisruption: cfg.AllowWorkloadDisruption,
MatchSELinuxLevelOnMigration: cfg.MatchSELinuxLevelOnMigration,
ParallelOutboundMigrationsPerNode: cfg.ParallelOutboundMigrationsPerNode,
NodeDrainTaintKey: cfg.NodeDrainTaintKey,
ParallelMigrationsPerCluster: cfg.ParallelMigrationsPerCluster,
DisableTLS: cfg.DisableTLS,
Network: cfg.Network,
}
return opts.DeepCopy()
}