@samitouri / QOSAMI-WSL
Code Commits Issues Pulls Sessions CI/CD
master
master
cs 229 lines 7.82 KB
Raw
1 // Copyright (C) Microsoft Corporation. All rights reserved.
2
3 using CommunityToolkit.Mvvm.ComponentModel;
4 using CommunityToolkit.Mvvm.Input;
5 using System.Windows.Input;
6 using WslSettings.Contracts.Services;
7
8 namespace WslSettings.ViewModels.Settings;
9
10 public partial class OptionalFeaturesViewModel : WslConfigSettingViewModel
11 {
12 private IWslConfigSetting? _memoryReclaimMode;
13 private IWslConfigSetting? _gUIApplications;
14 private IWslConfigSetting? _nestedVirtualization;
15 private IWslConfigSetting? _safeMode;
16 private IWslConfigSetting? _sparseVHD;
17 private IWslConfigSetting? _vMIdleTimeout;
18 private int _defaultVMIdleTimeout;
19 private IWslConfigSetting? _instanceIdleTimeout;
20 private int _defaultInstanceIdleTimeout;
21 private int _previousInstanceIdleTimeout;
22
23 public OptionalFeaturesViewModel()
24 {
25 InitializeConfigSettings();
26
27 VMIdleTimeout_ResetEnabled = !Equals(_defaultVMIdleTimeout, _vMIdleTimeout!.Int32Value);
28 InstanceIdleTimeout_ResetEnabled = !Equals(_defaultInstanceIdleTimeout, _instanceIdleTimeout!.Int32Value);
29 }
30
31 protected override void InitializeConfigSettings()
32 {
33 var wslConfigService = App.GetService<IWslConfigService>();
34 _memoryReclaimMode = wslConfigService.GetWslConfigSetting(WslConfigEntry.AutoMemoryReclaim);
35 _gUIApplications = wslConfigService.GetWslConfigSetting(WslConfigEntry.GUIApplicationsEnabled);
36 _nestedVirtualization = wslConfigService.GetWslConfigSetting(WslConfigEntry.NestedVirtualizationEnabled);
37 _safeMode = wslConfigService.GetWslConfigSetting(WslConfigEntry.SafeModeEnabled);
38 _sparseVHD = wslConfigService.GetWslConfigSetting(WslConfigEntry.SparseVHDEnabled);
39 _vMIdleTimeout = wslConfigService.GetWslConfigSetting(WslConfigEntry.VMIdleTimeout);
40 _instanceIdleTimeout = wslConfigService.GetWslConfigSetting(WslConfigEntry.InstanceIdleTimeout);
41
42 _defaultVMIdleTimeout = wslConfigService.GetWslConfigSetting(WslConfigEntry.VMIdleTimeout, true).Int32Value;
43 _defaultInstanceIdleTimeout = wslConfigService.GetWslConfigSetting(WslConfigEntry.InstanceIdleTimeout, true).Int32Value;
44
45 var configuredInstanceIdleTimeout = _instanceIdleTimeout!.Int32Value;
46 _previousInstanceIdleTimeout = configuredInstanceIdleTimeout < 0 ? _defaultInstanceIdleTimeout : configuredInstanceIdleTimeout;
47 }
48
49 public List<string> MemoryReclaimModes
50 {
51 get { return Enum.GetNames(typeof(MemoryReclaimMode)).ToList(); }
52 }
53
54 public int MemoryReclaimModeSelected
55 {
56 get { return (int)_memoryReclaimMode!.MemoryReclaimModeValue; }
57 set { Set(ref _memoryReclaimMode!, value); }
58 }
59
60 public bool IsOnGUIApplications
61 {
62 get { return _gUIApplications!.BoolValue; }
63 set { Set(ref _gUIApplications!, value); }
64 }
65
66 public bool IsOnNestedVirtualization
67 {
68 get { return _nestedVirtualization!.BoolValue; }
69 set { Set(ref _nestedVirtualization!, value); }
70 }
71
72 public bool IsOnSafeMode
73 {
74 get { return _safeMode!.BoolValue; }
75 set { Set(ref _safeMode!, value); }
76 }
77
78 public bool IsOnSparseVHD
79 {
80 get { return _sparseVHD!.BoolValue; }
81 set { Set(ref _sparseVHD!, value); }
82 }
83
84 // Keeping WSL running is driven by the distribution idle timeout: a negative value tells the
85 // service to never idle-terminate a distribution, and because the VM is only considered idle
86 // once every distribution has stopped, this keeps the WSL VM running as well.
87 public bool IsOnKeepWslRunning
88 {
89 get { return _instanceIdleTimeout!.Int32Value < 0; }
90 set
91 {
92 if (value)
93 {
94 var currentInstanceIdleTimeout = _instanceIdleTimeout!.Int32Value;
95 if (currentInstanceIdleTimeout >= 0)
96 {
97 _previousInstanceIdleTimeout = currentInstanceIdleTimeout;
98 }
99
100 Set(ref _instanceIdleTimeout!, -1, nameof(IsOnKeepWslRunning));
101 }
102 else
103 {
104 Set(ref _instanceIdleTimeout!, _previousInstanceIdleTimeout, nameof(IsOnKeepWslRunning));
105 }
106
107 OnPropertyChanged(nameof(InstanceIdleTimeout));
108 OnPropertyChanged(nameof(InstanceIdleTimeoutEnabled));
109 OnPropertyChanged(nameof(VMIdleTimeoutEnabled));
110 InstanceIdleTimeout_ResetEnabled = !Equals(_defaultInstanceIdleTimeout, _instanceIdleTimeout!.Int32Value);
111 }
112 }
113
114 public bool VMIdleTimeoutEnabled
115 {
116 get { return !IsOnKeepWslRunning; }
117 }
118
119 public bool InstanceIdleTimeoutEnabled
120 {
121 get { return !IsOnKeepWslRunning; }
122 }
123
124 public string VMIdleTimeout
125 {
126 get
127 {
128 return _vMIdleTimeout!.Int32Value.ToString();
129 }
130 set
131 {
132 if (ValidateInput(value, Constants.IntegerRegex))
133 {
134 if (Int32.TryParse(value, out int parsedValue))
135 {
136 Set(ref _vMIdleTimeout!, parsedValue);
137 }
138 else
139 {
140 OnPropertyChanged();
141 }
142 }
143 }
144 }
145
146 public void SetVMIdleTimeout_ResetEnabled(string? value)
147 {
148 if (Int32.TryParse(value, out Int32 parseResult))
149 {
150 VMIdleTimeout_ResetEnabled = !Equals(_defaultVMIdleTimeout, parseResult);
151 }
152 else
153 {
154 VMIdleTimeout_ResetEnabled = true;
155 }
156 }
157
158 private bool _vMIdleTimeout_ResetEnabled;
159
160 public bool VMIdleTimeout_ResetEnabled
161 {
162 get => _vMIdleTimeout_ResetEnabled;
163 set => SetProperty(ref _vMIdleTimeout_ResetEnabled, value);
164 }
165
166 private void VMIdleTimeout_ResetExecuted(string? param)
167 {
168 VMIdleTimeout = _defaultVMIdleTimeout.ToString();
169 }
170
171 public ICommand VMIdleTimeout_ResetCommand => new RelayCommand<string>(VMIdleTimeout_ResetExecuted);
172
173 public string InstanceIdleTimeout
174 {
175 get
176 {
177 return _instanceIdleTimeout!.Int32Value.ToString();
178 }
179 set
180 {
181 if (ValidateInput(value, Constants.IntegerRegex))
182 {
183 if (Int32.TryParse(value, out int parsedValue))
184 {
185 Set(ref _instanceIdleTimeout!, parsedValue);
186 if (parsedValue >= 0)
187 {
188 _previousInstanceIdleTimeout = parsedValue;
189 }
190
191 OnPropertyChanged(nameof(IsOnKeepWslRunning));
192 OnPropertyChanged(nameof(InstanceIdleTimeoutEnabled));
193 OnPropertyChanged(nameof(VMIdleTimeoutEnabled));
194 }
195 else
196 {
197 OnPropertyChanged();
198 }
199 }
200 }
201 }
202
203 public void SetInstanceIdleTimeout_ResetEnabled(string? value)
204 {
205 if (Int32.TryParse(value, out Int32 parseResult))
206 {
207 InstanceIdleTimeout_ResetEnabled = !Equals(_defaultInstanceIdleTimeout, parseResult);
208 }
209 else
210 {
211 InstanceIdleTimeout_ResetEnabled = true;
212 }
213 }
214
215 private bool _instanceIdleTimeout_ResetEnabled;
216
217 public bool InstanceIdleTimeout_ResetEnabled
218 {
219 get => _instanceIdleTimeout_ResetEnabled;
220 set => SetProperty(ref _instanceIdleTimeout_ResetEnabled, value);
221 }
222
223 private void InstanceIdleTimeout_ResetExecuted(string? param)
224 {
225 InstanceIdleTimeout = _defaultInstanceIdleTimeout.ToString();
226 }
227
228 public ICommand InstanceIdleTimeout_ResetCommand => new RelayCommand<string>(InstanceIdleTimeout_ResetExecuted);
229 }