createSchema: include type property
[pve-common.git] / src / PVE / CLIHandler.pm
1 package PVE::CLIHandler;
2
3 use strict;
4 use warnings;
5 use Data::Dumper;
6
7 use PVE::SafeSyslog;
8 use PVE::Exception qw(raise raise_param_exc);
9 use PVE::RESTHandler;
10 use PVE::PodParser;
11
12 use base qw(PVE::RESTHandler);
13
14 my $cmddef;
15 my $exename;
16
17 my $expand_command_name = sub {
18 my ($def, $cmd) = @_;
19
20 if (!$def->{$cmd}) {
21 my $expanded;
22 for my $k (keys(%$def)) {
23 if ($k =~ m/^$cmd/) {
24 if ($expanded) {
25 $expanded = undef; # more than one match
26 last;
27 } else {
28 $expanded = $k;
29 }
30 }
31 }
32 $cmd = $expanded if $expanded;
33 }
34 return $cmd;
35 };
36
37 my $complete_command_names = sub {
38 my $res = [];
39
40 return if ref($cmddef) ne 'HASH';
41
42 foreach my $cmd (keys %$cmddef) {
43 next if $cmd eq 'help';
44 push @$res, $cmd;
45 }
46
47 return $res;
48 };
49
50 __PACKAGE__->register_method ({
51 name => 'help',
52 path => 'help',
53 method => 'GET',
54 description => "Get help about specified command.",
55 parameters => {
56 additionalProperties => 0,
57 properties => {
58 cmd => {
59 description => "Command name",
60 type => 'string',
61 optional => 1,
62 completion => $complete_command_names,
63 },
64 verbose => {
65 description => "Verbose output format.",
66 type => 'boolean',
67 optional => 1,
68 },
69 },
70 },
71 returns => { type => 'null' },
72
73 code => sub {
74 my ($param) = @_;
75
76 die "not initialized" if !($cmddef && $exename);
77
78 my $cmd = $param->{cmd};
79
80 my $verbose = defined($cmd) && $cmd;
81 $verbose = $param->{verbose} if defined($param->{verbose});
82
83 if (!$cmd) {
84 if ($verbose) {
85 print_usage_verbose();
86 } else {
87 print_usage_short(\*STDOUT);
88 }
89 return undef;
90 }
91
92 $cmd = &$expand_command_name($cmddef, $cmd);
93
94 my ($class, $name, $arg_param, $uri_param) = @{$cmddef->{$cmd} || []};
95
96 raise_param_exc({ cmd => "no such command '$cmd'"}) if !$class;
97
98
99 my $str = $class->usage_str($name, "$exename $cmd", $arg_param, $uri_param, $verbose ? 'full' : 'short');
100 if ($verbose) {
101 print "$str\n";
102 } else {
103 print "USAGE: $str\n";
104 }
105
106 return undef;
107
108 }});
109
110 sub print_simple_pod_manpage {
111 my ($podfn, $class, $name, $arg_param, $uri_param) = @_;
112
113 my $synopsis = " $name help\n\n";
114 my $str = $class->usage_str($name, $name, $arg_param, $uri_param, 'long');
115 $str =~ s/^USAGE://;
116 $str =~ s/\n/\n /g;
117 $synopsis .= $str;
118
119 my $parser = PVE::PodParser->new();
120 $parser->{include}->{synopsis} = $synopsis;
121 $parser->parse_from_file($podfn);
122 }
123
124 sub print_pod_manpage {
125 my ($podfn) = @_;
126
127 die "not initialized" if !($cmddef && $exename);
128 die "no pod file specified" if !$podfn;
129
130 my $synopsis = "";
131
132 $synopsis .= " $exename <COMMAND> [ARGS] [OPTIONS]\n\n";
133
134 my $style = 'full'; # or should we use 'short'?
135 my $oldclass;
136 foreach my $cmd (sorted_commands()) {
137 my ($class, $name, $arg_param, $uri_param) = @{$cmddef->{$cmd}};
138 my $str = $class->usage_str($name, "$exename $cmd", $arg_param,
139 $uri_param, $style);
140 $str =~ s/^USAGE: //;
141
142 $synopsis .= "\n" if $oldclass && $oldclass ne $class;
143 $str =~ s/\n/\n /g;
144 $synopsis .= " $str\n\n";
145 $oldclass = $class;
146 }
147
148 $synopsis .= "\n";
149
150 my $parser = PVE::PodParser->new();
151 $parser->{include}->{synopsis} = $synopsis;
152 $parser->parse_from_file($podfn);
153 }
154
155 sub print_usage_verbose {
156
157 die "not initialized" if !($cmddef && $exename);
158
159 print "USAGE: $exename <COMMAND> [ARGS] [OPTIONS]\n\n";
160
161 foreach my $cmd (sort keys %$cmddef) {
162 my ($class, $name, $arg_param, $uri_param) = @{$cmddef->{$cmd}};
163 my $str = $class->usage_str($name, "$exename $cmd", $arg_param, $uri_param, 'full');
164 print "$str\n\n";
165 }
166 }
167
168 sub sorted_commands {
169 return sort { ($cmddef->{$a}->[0] cmp $cmddef->{$b}->[0]) || ($a cmp $b)} keys %$cmddef;
170 }
171
172 sub print_usage_short {
173 my ($fd, $msg) = @_;
174
175 die "not initialized" if !($cmddef && $exename);
176
177 print $fd "ERROR: $msg\n" if $msg;
178 print $fd "USAGE: $exename <COMMAND> [ARGS] [OPTIONS]\n";
179
180 my $oldclass;
181 foreach my $cmd (sorted_commands()) {
182 my ($class, $name, $arg_param, $uri_param) = @{$cmddef->{$cmd}};
183 my $str = $class->usage_str($name, "$exename $cmd", $arg_param, $uri_param, 'short');
184 print $fd "\n" if $oldclass && $oldclass ne $class;
185 print $fd " $str";
186 $oldclass = $class;
187 }
188 }
189
190 my $print_bash_completion = sub {
191 my ($cmddef, $simple_cmd, $bash_command, $cur, $prev) = @_;
192
193 my $debug = 0;
194
195 return if !(defined($cur) && defined($prev) && defined($bash_command));
196 return if !defined($ENV{COMP_LINE});
197 return if !defined($ENV{COMP_POINT});
198
199 my $cmdline = substr($ENV{COMP_LINE}, 0, $ENV{COMP_POINT});
200 print STDERR "\nCMDLINE: $ENV{COMP_LINE}\n" if $debug;
201
202 my $args = PVE::Tools::split_args($cmdline);
203 my $pos = scalar(@$args) - 2;
204 $pos += 1 if $cmdline =~ m/\s+$/;
205
206 print STDERR "CMDLINE:$pos:$cmdline\n" if $debug;
207
208 return if $pos < 0;
209
210 my $print_result = sub {
211 foreach my $p (@_) {
212 print "$p\n" if $p =~ m/^$cur/;
213 }
214 };
215
216 my $cmd;
217 if ($simple_cmd) {
218 $cmd = $simple_cmd;
219 } else {
220 if ($pos == 0) {
221 &$print_result(keys %$cmddef);
222 return;
223 }
224 $cmd = $args->[1];
225 }
226
227 my $def = $cmddef->{$cmd};
228 return if !$def;
229
230 print STDERR "CMDLINE1:$pos:$cmdline\n" if $debug;
231
232 my $skip_param = {};
233
234 my ($class, $name, $arg_param, $uri_param) = @$def;
235 $arg_param //= [];
236 $uri_param //= {};
237
238 map { $skip_param->{$_} = 1; } @$arg_param;
239 map { $skip_param->{$_} = 1; } keys %$uri_param;
240
241 my $fpcount = scalar(@$arg_param);
242
243 my $info = $class->map_method_by_name($name);
244
245 my $schema = $info->{parameters};
246 my $prop = $schema->{properties};
247
248 my $print_parameter_completion = sub {
249 my ($pname) = @_;
250 my $d = $prop->{$pname};
251 if ($d->{completion}) {
252 my $vt = ref($d->{completion});
253 if ($vt eq 'CODE') {
254 my $res = $d->{completion}->($cmd, $pname, $cur, $args);
255 &$print_result(@$res);
256 }
257 } elsif ($d->{type} eq 'boolean') {
258 &$print_result('0', '1');
259 } elsif ($d->{enum}) {
260 &$print_result(@{$d->{enum}});
261 }
262 };
263
264 # positional arguments
265 $pos += 1 if $simple_cmd;
266 if ($fpcount && $pos <= $fpcount) {
267 my $pname = $arg_param->[$pos -1];
268 &$print_parameter_completion($pname);
269 return;
270 }
271
272 my @option_list = ();
273 foreach my $key (keys %$prop) {
274 next if $skip_param->{$key};
275 push @option_list, "--$key";
276 }
277
278 if ($cur =~ m/^-/) {
279 &$print_result(@option_list);
280 return;
281 }
282
283 if ($prev =~ m/^--?(.+)$/ && $prop->{$1}) {
284 my $pname = $1;
285 &$print_parameter_completion($pname);
286 return;
287 }
288
289 &$print_result(@option_list);
290 };
291
292 sub verify_api {
293 my ($class) = @_;
294
295 # simply verify all registered methods
296 PVE::RESTHandler::validate_method_schemas();
297 }
298
299 my $get_exe_name = sub {
300 my ($class) = @_;
301
302 my $name = $class;
303 $name =~ s/^.*:://;
304 $name =~ s/_/-/g;
305
306 return $name;
307 };
308
309 sub generate_bash_completions {
310 my ($class) = @_;
311
312 # generate bash completion config
313
314 $exename = &$get_exe_name($class);
315
316 print <<__EOD__;
317 # $exename bash completion
318
319 # see http://tiswww.case.edu/php/chet/bash/FAQ
320 # and __ltrim_colon_completions() in /usr/share/bash-completion/bash_completion
321 # this modifies global var, but I found no better way
322 COMP_WORDBREAKS=\${COMP_WORDBREAKS//:}
323
324 complete -C '$exename bashcomplete' $exename
325 __EOD__
326 }
327
328 sub find_cli_class_source {
329 my ($name) = @_;
330
331 my $filename;
332
333 $name =~ s/-/_/g;
334
335 my $cpath = "PVE/CLI/${name}.pm";
336 my $spath = "PVE/Service/${name}.pm";
337 foreach my $p (@INC) {
338 foreach my $s (($cpath, $spath)) {
339 my $testfn = "$p/$s";
340 if (-f $testfn) {
341 $filename = $testfn;
342 last;
343 }
344 }
345 last if defined($filename);
346 }
347
348 return $filename;
349 }
350
351 sub generate_pod_manpage {
352 my ($class, $podfn) = @_;
353
354 $exename = &$get_exe_name($class);
355
356 $podfn = find_cli_class_source($exename) if !defined($podfn);
357
358 die "unable to find source for class '$class'" if !$podfn;
359
360 no strict 'refs';
361 my $def = ${"${class}::cmddef"};
362
363 if (ref($def) eq 'ARRAY') {
364 print_simple_pod_manpage($podfn, @$def);
365 } else {
366 $cmddef = $def;
367
368 $cmddef->{help} = [ __PACKAGE__, 'help', ['cmd'] ];
369
370 print_pod_manpage($podfn);
371 }
372 }
373
374 sub run_cli {
375 my ($class, $pwcallback, $podfn, $preparefunc) = @_;
376
377 $ENV{'PATH'} = '/sbin:/bin:/usr/sbin:/usr/bin';
378
379 $exename = &$get_exe_name($class);
380
381 initlog($exename);
382
383
384 if ($class !~ m/^PVE::Service::/) {
385 die "please run as root\n" if $> != 0;
386
387 PVE::INotify::inotify_init();
388
389 my $rpcenv = PVE::RPCEnvironment->init('cli');
390 $rpcenv->init_request();
391 $rpcenv->set_language($ENV{LANG});
392 $rpcenv->set_user('root@pam');
393 }
394
395 no strict 'refs';
396 my $def = ${"${class}::cmddef"};
397
398 if (ref($def) eq 'ARRAY') {
399 handle_simple_cmd($def, \@ARGV, $pwcallback, $podfn, $preparefunc);
400 } else {
401 $cmddef = $def;
402 my $cmd = shift @ARGV;
403 handle_cmd($cmddef, $exename, $cmd, \@ARGV, $pwcallback, $podfn, $preparefunc);
404 }
405
406 exit 0;
407 }
408
409 sub handle_cmd {
410 my ($def, $cmdname, $cmd, $args, $pwcallback, $podfn, $preparefunc) = @_;
411
412 $cmddef = $def;
413 $exename = $cmdname;
414
415 $cmddef->{help} = [ __PACKAGE__, 'help', ['cmd'] ];
416
417 if (!$cmd) {
418 print_usage_short (\*STDERR, "no command specified");
419 exit (-1);
420 } elsif ($cmd eq 'verifyapi') {
421 PVE::RESTHandler::validate_method_schemas();
422 return;
423 } elsif ($cmd eq 'printmanpod') {
424 $podfn = find_cli_class_source($exename) if !defined($podfn);
425 print_pod_manpage($podfn);
426 return;
427 } elsif ($cmd eq 'bashcomplete') {
428 &$print_bash_completion($cmddef, 0, @$args);
429 return;
430 }
431
432 &$preparefunc() if $preparefunc;
433
434 $cmd = &$expand_command_name($cmddef, $cmd);
435
436 my ($class, $name, $arg_param, $uri_param, $outsub) = @{$cmddef->{$cmd} || []};
437
438 if (!$class) {
439 print_usage_short (\*STDERR, "unknown command '$cmd'");
440 exit (-1);
441 }
442
443 my $prefix = "$exename $cmd";
444 my $res = $class->cli_handler($prefix, $name, \@ARGV, $arg_param, $uri_param, $pwcallback);
445
446 &$outsub($res) if $outsub;
447 }
448
449 sub handle_simple_cmd {
450 my ($def, $args, $pwcallback, $podfn, $preparefunc) = @_;
451
452 my ($class, $name, $arg_param, $uri_param, $outsub) = @{$def};
453 die "no class specified" if !$class;
454
455 if (scalar(@$args) >= 1) {
456 if ($args->[0] eq 'help') {
457 my $str = "USAGE: $name help\n";
458 $str .= $class->usage_str($name, $name, $arg_param, $uri_param, 'long');
459 print STDERR "$str\n\n";
460 return;
461 } elsif ($args->[0] eq 'bashcomplete') {
462 shift @$args;
463 &$print_bash_completion({ $name => $def }, $name, @$args);
464 return;
465 } elsif ($args->[0] eq 'verifyapi') {
466 PVE::RESTHandler::validate_method_schemas();
467 return;
468 } elsif ($args->[0] eq 'printmanpod') {
469 $podfn = find_cli_class_source($name) if !defined($podfn);
470 print_simple_pod_manpage($podfn, @$def);
471 return;
472 }
473 }
474
475 &$preparefunc() if $preparefunc;
476
477 my $res = $class->cli_handler($name, $name, \@ARGV, $arg_param, $uri_param, $pwcallback);
478
479 &$outsub($res) if $outsub;
480 }
481
482 1;