]>
Commit | Line | Data |
---|---|---|
1 | package PVE::Storage::GlusterfsPlugin; | |
2 | ||
3 | use strict; | |
4 | use warnings; | |
5 | use IO::File; | |
6 | use File::Path; | |
7 | use PVE::Tools qw(run_command); | |
8 | use PVE::ProcFSTools; | |
9 | use PVE::Network; | |
10 | use PVE::Storage::Plugin; | |
11 | use PVE::JSONSchema qw(get_standard_option); | |
12 | ||
13 | use base qw(PVE::Storage::Plugin); | |
14 | ||
15 | # Glusterfs helper functions | |
16 | ||
17 | my $server_test_results = {}; | |
18 | ||
19 | my $get_active_server = sub { | |
20 | my ($scfg, $return_default_if_offline) = @_; | |
21 | ||
22 | my $defaultserver = $scfg->{server} ? $scfg->{server} : 'localhost'; | |
23 | ||
24 | if ($return_default_if_offline && !defined($scfg->{server2})) { | |
25 | # avoid delays (there is no backup server anyways) | |
26 | return $defaultserver; | |
27 | } | |
28 | ||
29 | my $serverlist = [ $defaultserver ]; | |
30 | push @$serverlist, $scfg->{server2} if $scfg->{server2}; | |
31 | ||
32 | my $ctime = time(); | |
33 | foreach my $server (@$serverlist) { | |
34 | my $stat = $server_test_results->{$server}; | |
35 | return $server if $stat && $stat->{active} && (($ctime - $stat->{time}) <= 2); | |
36 | } | |
37 | ||
38 | foreach my $server (@$serverlist) { | |
39 | my $status = 0; | |
40 | ||
41 | if ($server && $server ne 'localhost' && $server ne '127.0.0.1' && $server ne '::1') { | |
42 | # ping the gluster daemon default port (24007) as heuristic | |
43 | $status = PVE::Network::tcp_ping($server, 24007, 2); | |
44 | ||
45 | } else { | |
46 | ||
47 | my $parser = sub { | |
48 | my $line = shift; | |
49 | ||
50 | if ($line =~ m/Status: Started$/) { | |
51 | $status = 1; | |
52 | } | |
53 | }; | |
54 | ||
55 | my $cmd = ['/usr/sbin/gluster', 'volume', 'info', $scfg->{volume}]; | |
56 | ||
57 | run_command($cmd, errmsg => "glusterfs error", errfunc => sub {}, outfunc => $parser); | |
58 | } | |
59 | ||
60 | $server_test_results->{$server} = { time => time(), active => $status }; | |
61 | return $server if $status; | |
62 | } | |
63 | ||
64 | return $defaultserver if $return_default_if_offline; | |
65 | ||
66 | return undef; | |
67 | }; | |
68 | ||
69 | sub glusterfs_is_mounted { | |
70 | my ($volume, $mountpoint, $mountdata) = @_; | |
71 | ||
72 | $mountdata = PVE::ProcFSTools::parse_proc_mounts() if !$mountdata; | |
73 | ||
74 | return $mountpoint if grep { | |
75 | $_->[2] eq 'fuse.glusterfs' && | |
76 | $_->[0] =~ /^\S+:\Q$volume\E$/ && | |
77 | $_->[1] eq $mountpoint | |
78 | } @$mountdata; | |
79 | return undef; | |
80 | } | |
81 | ||
82 | sub glusterfs_mount { | |
83 | my ($server, $volume, $mountpoint) = @_; | |
84 | ||
85 | my $source = "$server:$volume"; | |
86 | ||
87 | my $cmd = ['/bin/mount', '-t', 'glusterfs', $source, $mountpoint]; | |
88 | ||
89 | run_command($cmd, errmsg => "mount error"); | |
90 | } | |
91 | ||
92 | # Configuration | |
93 | ||
94 | sub type { | |
95 | return 'glusterfs'; | |
96 | } | |
97 | ||
98 | sub plugindata { | |
99 | return { | |
100 | content => [ { images => 1, vztmpl => 1, iso => 1, backup => 1, snippets => 1}, | |
101 | { images => 1 }], | |
102 | format => [ { raw => 1, qcow2 => 1, vmdk => 1 } , 'raw' ], | |
103 | }; | |
104 | } | |
105 | ||
106 | sub properties { | |
107 | return { | |
108 | volume => { | |
109 | description => "Glusterfs Volume.", | |
110 | type => 'string', | |
111 | }, | |
112 | server2 => { | |
113 | description => "Backup volfile server IP or DNS name.", | |
114 | type => 'string', format => 'pve-storage-server', | |
115 | requires => 'server', | |
116 | }, | |
117 | transport => { | |
118 | description => "Gluster transport: tcp or rdma", | |
119 | type => 'string', | |
120 | enum => ['tcp', 'rdma', 'unix'], | |
121 | }, | |
122 | }; | |
123 | } | |
124 | ||
125 | sub options { | |
126 | return { | |
127 | path => { fixed => 1 }, | |
128 | server => { optional => 1 }, | |
129 | server2 => { optional => 1 }, | |
130 | volume => { fixed => 1 }, | |
131 | transport => { optional => 1 }, | |
132 | nodes => { optional => 1 }, | |
133 | disable => { optional => 1 }, | |
134 | maxfiles => { optional => 1 }, | |
135 | 'prune-backups' => { optional => 1 }, | |
136 | 'max-protected-backups' => { optional => 1 }, | |
137 | content => { optional => 1 }, | |
138 | format => { optional => 1 }, | |
139 | mkdir => { optional => 1 }, | |
140 | bwlimit => { optional => 1 }, | |
141 | preallocation => { optional => 1 }, | |
142 | }; | |
143 | } | |
144 | ||
145 | ||
146 | sub check_config { | |
147 | my ($class, $sectionId, $config, $create, $skipSchemaCheck) = @_; | |
148 | ||
149 | $config->{path} = "/mnt/pve/$sectionId" if $create && !$config->{path}; | |
150 | ||
151 | return $class->SUPER::check_config($sectionId, $config, $create, $skipSchemaCheck); | |
152 | } | |
153 | ||
154 | # Storage implementation | |
155 | ||
156 | sub parse_name_dir { | |
157 | my $name = shift; | |
158 | ||
159 | if ($name =~ m!^((base-)?[^/\s]+\.(raw|qcow2|vmdk))$!) { | |
160 | return ($1, $3, $2); | |
161 | } | |
162 | ||
163 | die "unable to parse volume filename '$name'\n"; | |
164 | } | |
165 | ||
166 | sub path { | |
167 | my ($class, $scfg, $volname, $storeid, $snapname) = @_; | |
168 | ||
169 | my ($vtype, $name, $vmid, undef, undef, $isBase, $format) = | |
170 | $class->parse_volname($volname); | |
171 | ||
172 | # Note: qcow2/qed has internal snapshot, so path is always | |
173 | # the same (with or without snapshot => same file). | |
174 | die "can't snapshot this image format\n" | |
175 | if defined($snapname) && $format !~ m/^(qcow2|qed)$/; | |
176 | ||
177 | my $path = undef; | |
178 | if ($vtype eq 'images') { | |
179 | ||
180 | my $server = &$get_active_server($scfg, 1); | |
181 | my $glustervolume = $scfg->{volume}; | |
182 | my $transport = $scfg->{transport}; | |
183 | my $protocol = "gluster"; | |
184 | ||
185 | if ($transport) { | |
186 | $protocol = "gluster+$transport"; | |
187 | } | |
188 | ||
189 | $path = "$protocol://$server/$glustervolume/images/$vmid/$name"; | |
190 | ||
191 | } else { | |
192 | my $dir = $class->get_subdir($scfg, $vtype); | |
193 | $path = "$dir/$name"; | |
194 | } | |
195 | ||
196 | return wantarray ? ($path, $vmid, $vtype) : $path; | |
197 | } | |
198 | ||
199 | sub clone_image { | |
200 | my ($class, $scfg, $storeid, $volname, $vmid, $snap) = @_; | |
201 | ||
202 | die "storage definition has no path\n" if !$scfg->{path}; | |
203 | ||
204 | my ($vtype, $basename, $basevmid, undef, undef, $isBase, $format) = | |
205 | $class->parse_volname($volname); | |
206 | ||
207 | die "clone_image on wrong vtype '$vtype'\n" if $vtype ne 'images'; | |
208 | ||
209 | die "this storage type does not support clone_image on snapshot\n" if $snap; | |
210 | ||
211 | die "this storage type does not support clone_image on subvolumes\n" if $format eq 'subvol'; | |
212 | ||
213 | die "clone_image only works on base images\n" if !$isBase; | |
214 | ||
215 | my $imagedir = $class->get_subdir($scfg, 'images'); | |
216 | $imagedir .= "/$vmid"; | |
217 | ||
218 | mkpath $imagedir; | |
219 | ||
220 | my $name = $class->find_free_diskname($storeid, $scfg, $vmid, "qcow2", 1); | |
221 | ||
222 | warn "clone $volname: $vtype, $name, $vmid to $name (base=../$basevmid/$basename)\n"; | |
223 | ||
224 | my $path = "$imagedir/$name"; | |
225 | ||
226 | die "disk image '$path' already exists\n" if -e $path; | |
227 | ||
228 | my $server = &$get_active_server($scfg, 1); | |
229 | my $glustervolume = $scfg->{volume}; | |
230 | my $volumepath = "gluster://$server/$glustervolume/images/$vmid/$name"; | |
231 | ||
232 | my $cmd = ['/usr/bin/qemu-img', 'create', '-b', "../$basevmid/$basename", | |
233 | '-F', $format, '-f', 'qcow2', $volumepath]; | |
234 | ||
235 | run_command($cmd, errmsg => "unable to create image"); | |
236 | ||
237 | return "$basevmid/$basename/$vmid/$name"; | |
238 | } | |
239 | ||
240 | sub alloc_image { | |
241 | my ($class, $storeid, $scfg, $vmid, $fmt, $name, $size) = @_; | |
242 | ||
243 | my $imagedir = $class->get_subdir($scfg, 'images'); | |
244 | $imagedir .= "/$vmid"; | |
245 | ||
246 | mkpath $imagedir; | |
247 | ||
248 | $name = $class->find_free_diskname($storeid, $scfg, $vmid, $fmt, 1) if !$name; | |
249 | ||
250 | my (undef, $tmpfmt) = parse_name_dir($name); | |
251 | ||
252 | die "illegal name '$name' - wrong extension for format ('$tmpfmt != '$fmt')\n" | |
253 | if $tmpfmt ne $fmt; | |
254 | ||
255 | my $path = "$imagedir/$name"; | |
256 | ||
257 | die "disk image '$path' already exists\n" if -e $path; | |
258 | ||
259 | my $server = &$get_active_server($scfg, 1); | |
260 | my $glustervolume = $scfg->{volume}; | |
261 | my $volumepath = "gluster://$server/$glustervolume/images/$vmid/$name"; | |
262 | ||
263 | my $cmd = ['/usr/bin/qemu-img', 'create']; | |
264 | ||
265 | my $prealloc_opt = PVE::Storage::Plugin::preallocation_cmd_option($scfg, $fmt); | |
266 | push @$cmd, '-o', $prealloc_opt if defined($prealloc_opt); | |
267 | ||
268 | push @$cmd, '-f', $fmt, $volumepath, "${size}K"; | |
269 | ||
270 | eval { run_command($cmd, errmsg => "unable to create image"); }; | |
271 | if ($@) { | |
272 | unlink $path; | |
273 | rmdir $imagedir; | |
274 | die "$@"; | |
275 | } | |
276 | ||
277 | return "$vmid/$name"; | |
278 | } | |
279 | ||
280 | sub status { | |
281 | my ($class, $storeid, $scfg, $cache) = @_; | |
282 | ||
283 | $cache->{mountdata} = PVE::ProcFSTools::parse_proc_mounts() | |
284 | if !$cache->{mountdata}; | |
285 | ||
286 | my $path = $scfg->{path}; | |
287 | ||
288 | my $volume = $scfg->{volume}; | |
289 | ||
290 | return undef if !glusterfs_is_mounted($volume, $path, $cache->{mountdata}); | |
291 | ||
292 | return $class->SUPER::status($storeid, $scfg, $cache); | |
293 | } | |
294 | ||
295 | sub activate_storage { | |
296 | my ($class, $storeid, $scfg, $cache) = @_; | |
297 | ||
298 | $cache->{mountdata} = PVE::ProcFSTools::parse_proc_mounts() | |
299 | if !$cache->{mountdata}; | |
300 | ||
301 | my $path = $scfg->{path}; | |
302 | my $volume = $scfg->{volume}; | |
303 | ||
304 | if (!glusterfs_is_mounted($volume, $path, $cache->{mountdata})) { | |
305 | ||
306 | mkpath $path if !(defined($scfg->{mkdir}) && !$scfg->{mkdir}); | |
307 | ||
308 | die "unable to activate storage '$storeid' - " . | |
309 | "directory '$path' does not exist\n" if ! -d $path; | |
310 | ||
311 | my $server = &$get_active_server($scfg, 1); | |
312 | ||
313 | glusterfs_mount($server, $volume, $path); | |
314 | } | |
315 | ||
316 | $class->SUPER::activate_storage($storeid, $scfg, $cache); | |
317 | } | |
318 | ||
319 | sub deactivate_storage { | |
320 | my ($class, $storeid, $scfg, $cache) = @_; | |
321 | ||
322 | $cache->{mountdata} = PVE::ProcFSTools::parse_proc_mounts() | |
323 | if !$cache->{mountdata}; | |
324 | ||
325 | my $path = $scfg->{path}; | |
326 | my $volume = $scfg->{volume}; | |
327 | ||
328 | if (glusterfs_is_mounted($volume, $path, $cache->{mountdata})) { | |
329 | my $cmd = ['/bin/umount', $path]; | |
330 | run_command($cmd, errmsg => 'umount error'); | |
331 | } | |
332 | } | |
333 | ||
334 | sub activate_volume { | |
335 | my ($class, $storeid, $scfg, $volname, $snapname, $cache) = @_; | |
336 | ||
337 | # do nothing by default | |
338 | } | |
339 | ||
340 | sub deactivate_volume { | |
341 | my ($class, $storeid, $scfg, $volname, $snapname, $cache) = @_; | |
342 | ||
343 | # do nothing by default | |
344 | } | |
345 | ||
346 | sub check_connection { | |
347 | my ($class, $storeid, $scfg, $cache) = @_; | |
348 | ||
349 | my $server = &$get_active_server($scfg); | |
350 | ||
351 | return defined($server) ? 1 : 0; | |
352 | } | |
353 | ||
354 | 1; |