Convert some more files to GPLv3.
[jra/samba/.git] / source4 / selftest / win / VMHost.pm
1 #!/usr/bin/perl -w
2
3 # A perl object to provide a simple, unified method of handling some
4 # VMware Server VM management functions using the perl and VIX API's.
5 # Copyright Brad Henry <brad@samba.org> 2006
6 # Released under the GNU GPL version 3 or later.
7
8 # VMware Perl API
9 use VMware::VmPerl;
10 use VMware::VmPerl::VM;
11 use VMware::VmPerl::ConnectParams;
12
13 # VMware C bindings
14 use VMware::Vix::Simple;
15 use VMware::Vix::API::Constants;
16
17 # Create a class to abstract from the Vix and VMPerl APIs.
18 { package VMHost;
19         my $perl_vm = VMware::VmPerl::VM::new();
20         my $perl_vm_credentials;
21         my $vix_vm;
22         my $vix_vm_host;
23
24         my $err_code = 0;
25         my $err_str = "";
26
27         my $hostname;
28         my $port;
29         my $username;
30         my $password;
31         my $vm_cfg_path;
32         my $guest_admin_username;
33         my $guest_admin_password;
34
35         sub error {
36                 my $old_err_code = $err_code;
37                 my $old_err_str = $err_str;
38                 $err_code = 0;
39                 $err_str = "";
40                 return ($old_err_code, $old_err_str);
41         }
42
43         # Power on the guest if it isn't already running.
44         # Returns 0 when the guest is already running, and
45         # if not, it waits until it is started.
46         sub start_guest {
47                 my $vm_power_state = $perl_vm->get_execution_state();
48                 if (!defined($vm_power_state)) {
49                         ($err_code, $err_str) = $perl_vm->get_last_error();
50                         return ($err_code);
51                 }
52                 if ($vm_power_state == VMware::VmPerl::VM_EXECUTION_STATE_OFF
53                         || $vm_power_state ==
54                                 VMware::VmPerl::VM_EXECUTION_STATE_SUSPENDED)
55                 {
56                         if (!$perl_vm->start()) {
57                                 ($err_code, $err_str) =
58                                         $perl_vm->get_last_error();
59                                 return ($err_code);
60                         }
61                         while ($perl_vm->get_tools_last_active() == 0) {
62                                 sleep(60);
63                         }
64                 }
65                 return ($err_code);
66         }
67
68         sub host_connect {
69                 # When called as a method, the first parameter passed is the
70                 # name of the method. Called locally, this function will lose
71                 # the first parameter.
72                 shift @_;
73                 ($hostname, $port, $username, $password, $vm_cfg_path,
74                         $guest_admin_username, $guest_admin_password) = @_;
75
76                 # Connect to host using vmperl api.
77                 $perl_vm_credentials =
78                         VMware::VmPerl::ConnectParams::new($hostname, $port,
79                                 $username, $password);
80                 if (!$perl_vm->connect($perl_vm_credentials, $vm_cfg_path)) {
81                         ($err_code, $err_str) = $perl_vm->get_last_error();
82                         undef $perl_vm;
83                         return ($err_code);
84                 }
85
86                 # Connect to host using vix api.
87                 ($err_code, $vix_vm_host) =
88                         VMware::Vix::Simple::HostConnect(
89                                 VMware::Vix::Simple::VIX_API_VERSION,
90                                 VMware::Vix::Simple::VIX_SERVICEPROVIDER_VMWARE_SERVER,
91                                 $hostname, $port, $username, $password,
92                                 0, VMware::Vix::Simple::VIX_INVALID_HANDLE);
93                 if ($err_code != VMware::Vix::Simple::VIX_OK) {
94                         $err_str =
95                                 VMware::Vix::Simple::GetErrorText($err_code);
96                         undef $perl_vm;
97                         undef $vix_vm;
98                         undef $vix_vm_host;
99                         return ($err_code);
100                 }
101
102                 # Power on our guest os if it isn't already running.
103                 $err_code = start_guest();
104                 if ($err_code != 0) {
105                         my $old_err_str = $err_str;
106                         $err_str = "Starting guest power after connect " .
107                                         "failed: " . $old_err_str;
108                         undef $perl_vm;
109                         undef $vix_vm;
110                         undef $vix_vm_host;
111                         return ($err_code);
112                 }
113
114                 # Open VM.
115                 ($err_code, $vix_vm) =
116                         VMware::Vix::Simple::VMOpen($vix_vm_host, $vm_cfg_path);
117                 if ($err_code != VMware::Vix::Simple::VIX_OK) {
118                         $err_str =
119                                 VMware::Vix::Simple::GetErrorText($err_code);
120                         undef $perl_vm;
121                         undef $vix_vm;
122                         undef $vix_vm_host;
123                         return ($err_code);
124                 }
125
126                 # Login to $vix_vm guest OS.
127                 $err_code = VMware::Vix::Simple::VMLoginInGuest($vix_vm,
128                                 $guest_admin_username, $guest_admin_password,
129                                 0);
130                 if ($err_code != VMware::Vix::Simple::VIX_OK) {
131                         $err_str =
132                                 VMware::Vix::Simple::GetErrorText($err_code);
133                         undef $perl_vm;
134                         undef $vix_vm;
135                         undef $vix_vm_host;
136                         return ($err_code);
137                 }
138                 return ($err_code);
139         }
140
141         sub host_disconnect {
142                 undef $perl_vm;
143
144                 $perl_vm = VMware::VmPerl::VM::new();
145                 if (!$perl_vm) {
146                         $err_code = 1;
147                         $err_str = "Error creating new VmPerl object";
148                 }
149
150                 undef $vix_vm;
151                 VMware::Vix::Simple::HostDisconnect($vix_vm_host);
152                 VMware::Vix::Simple::ReleaseHandle($vix_vm_host);
153                 return ($err_code);
154         }
155
156         sub host_reconnect {
157                 $err_code = host_disconnect();
158                 if ($err_code != 0) {
159                         my $old_err_str = $err_str;
160                         $err_str = "Disconnecting from host failed: " .
161                                         $old_err_str;
162                         return ($err_code);
163                 }
164
165                 $err_code = host_connect(NULL, $hostname, $port, $username,
166                                 $password, $vm_cfg_path, $guest_admin_username,
167                                 $guest_admin_password);
168                 if ($err_code != 0) {
169                         my $old_err_str = $err_str;
170                         $err_str = "Re-connecting to host failed: " .
171                                         $old_err_str;
172                         return ($err_code);
173                 }
174                 return ($err_code);
175         }
176
177         sub create_snapshot {
178                 my $snapshot;
179
180                 ($err_code, $snapshot) =
181                         VMware::Vix::Simple::VMCreateSnapshot($vix_vm,
182                         "Snapshot", "Created by vm_setup.pl", 0,
183                         VMware::Vix::Simple::VIX_INVALID_HANDLE);
184
185                 VMware::Vix::Simple::ReleaseHandle($snapshot);
186
187                 if ($err_code != VMware::Vix::Simple::VIX_OK) {
188                         $err_str =
189                                 VMware::Vix::Simple::GetErrorText($err_code);
190                         return $err_code;
191                 }
192
193                 $err_code = host_reconnect();
194                 if ($err_code != 0) {
195                         my $old_err_str = $err_str;
196                         $err_str = "Reconnecting to host after creating " .
197                                         "snapshot: " . $old_err_str;
198                         return ($err_code);
199                 }
200                 return ($err_code);
201         }
202
203         sub revert_snapshot {
204                 # Because of problems with VMRevertToSnapshot(), we have to
205                 # rely on the guest having set 'Revert to Snapshot' following
206                 # a power-off event.
207                 $err_code = VMware::Vix::Simple::VMPowerOff($vix_vm, 0);
208                 if ($err_code != VMware::Vix::Simple::VIX_OK) {
209                         $err_str =
210                                 VMware::Vix::Simple::GetErrorText($err_code);
211                         return $err_code;
212                 }
213
214                 # host_reconnect() will power-on a guest in a non-running state.
215                 $err_code = host_reconnect();
216                 if ($err_code != 0) {
217                         my $old_err_str = $err_str;
218                         $err_str = "Reconnecting to host after reverting " .
219                                         "snapshot: " . $old_err_str;
220                         return ($err_code);
221                 }
222                 return ($err_code);
223         }
224
225         # $dest_path must exist. It doesn't get created.
226         sub copy_files_to_guest {
227                 shift @_;
228                 my (%files) = @_;
229
230                 my $src_file;
231                 my $dest_file;
232
233                 foreach $src_file (keys(%files)) {
234                         $dest_file = $files{$src_file};
235                         $err_code =
236                                 VMware::Vix::Simple::VMCopyFileFromHostToGuest(
237                                         $vix_vm, $src_file, $dest_file, 0,
238                                         VMware::Vix::Simple::VIX_INVALID_HANDLE);
239                         if ($err_code != VMware::Vix::Simple::VIX_OK) {
240                                 $err_str = "Copying $src_file: " .
241                                         VMware::Vix::Simple::GetErrorText(
242                                                 $err_code);
243                                 return $err_code;
244                         }
245                 }
246                 return $err_code;
247         }
248
249         sub copy_to_guest {
250                 # Read parameters $src_path, $dest_path.
251                 shift @_;
252                 my ($src_path, $dest_dir) = @_;
253
254                 my $len = length($dest_dir);
255                 my $idx = rindex($dest_dir, '\\');
256                 if ($idx != ($len - 1)) {
257                         $err_code = -1;
258                         $err_str = "Destination $dest_dir must be a " .
259                                         "directory path";
260                         return ($err_code);
261                 }
262
263                 # Create the directory $dest_path on the guest VM filesystem.
264                 my $cmd = "cmd.exe ";
265                 my $cmd_args = "/C MKDIR " . $dest_dir;
266                 $err_code = run_on_guest(NULL, $cmd, $cmd_args);
267                 if ( $err_code != 0) {
268                         my $old_err_str = $err_str;
269                         $err_str = "Creating directory $dest_dir on host: " .
270                                         $old_err_str;
271                         return ($err_code);
272                 }
273
274                 # If $src_filepath specifies a file, create it in $dest_path
275                 # and keep the same name.
276                 # If $src_path is a directory, create the files it contains in
277                 # $dest_path, keeping the same names.
278                 $len = length($src_path);
279                 my %files;
280                 $idx = rindex($src_path, '/');
281                 if ($idx == ($len - 1)) {
282                         # $src_path is a directory.
283                         if (!opendir (DIR_HANDLE, $src_path)) {
284                                 $err_code = -1;
285                                 $err_str = "Error opening directory $src_path";
286                                 return $err_code;
287                         }
288
289                         foreach $file (readdir DIR_HANDLE) {
290                                 my $src_file = $src_path . $file;
291
292                                 if (!opendir(DIR_HANDLE2, $src_file)) {
293                                         # We aren't interested in subdirs.
294                                         my $dest_path = $dest_dir . $file;
295                                         $files{$src_file} = $dest_path;
296                                 } else {
297                                         closedir(DIR_HANDLE2);
298                                 }
299                         }
300                 } else {
301                         # Strip if preceeding path from $src_path.
302                         my $src_file = substr($src_path, ($idx + 1), $len);
303                         my $dest_path = $dest_dir . $src_file;
304
305                         # Add $src_path => $dest_path to %files.
306                         $files{$src_path} = $dest_path;
307                 }
308
309                 $err_code = copy_files_to_guest(NULL, %files);
310                 if ($err_code != 0) {
311                         my $old_err_str = $err_str;
312                         $err_str = "Copying files to host after " .
313                                 "populating %files: " . $old_err_str;
314                         return ($err_code);
315                 }
316                 return ($err_code);
317         }
318
319         sub run_on_guest {
320                 # Read parameters $cmd, $cmd_args.
321                 shift @_;
322                 my ($cmd, $cmd_args) = @_;
323
324                 $err_code = VMware::Vix::Simple::VMRunProgramInGuest($vix_vm,
325                                 $cmd, $cmd_args, 0,
326                                 VMware::Vix::Simple::VIX_INVALID_HANDLE);
327                 if ($err_code != VMware::Vix::Simple::VIX_OK) {
328                         $err_str = VMware::Vix::Simple::GetErrorText(
329                                         $err_code);
330                         return ($err_code);
331                 }
332
333                 return ($err_code);
334         }
335
336         sub get_guest_ip {
337                 my $guest_ip = $perl_vm->get_guest_info('ip');
338
339                 if (!defined($guest_ip)) {
340                         ($err_code, $err_str) = $perl_vm->get_last_error();
341                         return NULL;
342                 }
343
344                 if (!($guest_ip)) {
345                         $err_code = 1;
346                         $err_str = "Guest did not set the 'ip' variable";
347                         return NULL;
348                 }
349                 return $guest_ip;
350         }
351
352         sub DESTROY {
353                 host_disconnect();
354                 undef $perl_vm;
355                 undef $vix_vm_host;
356         }
357 }
358
359 return TRUE;