cli: refactor and use $cmddef directly
[pve-common.git] / src / PVE / CLIHandler.pm
1 package PVE::CLIHandler;
2
3 use strict;
4 use warnings;
5
6 use PVE::SafeSyslog;
7 use PVE::Exception qw(raise raise_param_exc);
8 use PVE::RESTHandler;
9 use PVE::INotify;
10
11 use base qw(PVE::RESTHandler);
12
13 my $cmddef;
14 my $exename;
15 my $cli_handler_class;
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 && $cli_handler_class);
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         my $pwcallback = $cli_handler_class->can('read_password');
99         my $stringfilemap = $cli_handler_class->can('string_param_file_mapping');
100
101         my $str = $class->usage_str($name, "$exename $cmd", $arg_param, $uri_param,
102                                     $verbose ? 'full' : 'short', $pwcallback,
103                                     $stringfilemap);
104         if ($verbose) {
105             print "$str\n";
106         } else {
107             print "USAGE: $str\n";
108         }
109
110         return undef;
111
112     }});
113
114 sub print_simple_asciidoc_synopsis {
115     my ($class, $name, $arg_param, $uri_param) = @_;
116
117     die "not initialized" if !$cli_handler_class;
118
119     my $pwcallback = $cli_handler_class->can('read_password');
120     my $stringfilemap = $cli_handler_class->can('string_param_file_mapping');
121
122     my $synopsis = "*${name}* `help`\n\n";
123
124     $synopsis .= $class->usage_str($name, $name, $arg_param, $uri_param,
125                                    'asciidoc', $pwcallback, $stringfilemap);
126
127     return $synopsis;
128 }
129
130 sub print_asciidoc_synopsis {
131
132     die "not initialized" if !($cmddef && $exename && $cli_handler_class);
133
134     my $pwcallback = $cli_handler_class->can('read_password');
135     my $stringfilemap = $cli_handler_class->can('string_param_file_mapping');
136
137     my $synopsis = "";
138
139     $synopsis .= "*${exename}* `<COMMAND> [ARGS] [OPTIONS]`\n\n";
140
141     my $oldclass;
142     foreach my $cmd (sort keys %$cmddef) {
143         my ($class, $name, $arg_param, $uri_param) = @{$cmddef->{$cmd}};
144         my $str = $class->usage_str($name, "$exename $cmd", $arg_param,
145                                     $uri_param, 'asciidoc', $pwcallback,
146                                     $stringfilemap);
147         $synopsis .= "\n" if $oldclass && $oldclass ne $class;
148
149         $synopsis .= "$str\n\n";
150         $oldclass = $class;
151     }
152
153     $synopsis .= "\n";
154
155     return $synopsis;
156 }
157
158 sub print_usage_verbose {
159
160     die "not initialized" if !($cmddef && $exename && $cli_handler_class);
161
162     my $pwcallback = $cli_handler_class->can('read_password');
163     my $stringfilemap = $cli_handler_class->can('string_param_file_mapping');
164
165     print "USAGE: $exename <COMMAND> [ARGS] [OPTIONS]\n\n";
166
167     foreach my $cmd (sort keys %$cmddef) {
168         my ($class, $name, $arg_param, $uri_param) = @{$cmddef->{$cmd}};
169         my $str = $class->usage_str($name, "$exename $cmd", $arg_param, $uri_param,
170                                     'full', $pwcallback, $stringfilemap);
171         print "$str\n\n";
172     }
173 }
174
175 sub sorted_commands {   
176     return sort { ($cmddef->{$a}->[0] cmp $cmddef->{$b}->[0]) || ($a cmp $b)} keys %$cmddef;
177 }
178
179 sub print_usage_short {
180     my ($fd, $msg) = @_;
181
182     die "not initialized" if !($cmddef && $exename && $cli_handler_class);
183
184     my $pwcallback = $cli_handler_class->can('read_password');
185     my $stringfilemap = $cli_handler_class->can('string_param_file_mapping');
186
187     print $fd "ERROR: $msg\n" if $msg;
188     print $fd "USAGE: $exename <COMMAND> [ARGS] [OPTIONS]\n";
189
190     my $oldclass;
191     foreach my $cmd (sorted_commands()) {
192         my ($class, $name, $arg_param, $uri_param) = @{$cmddef->{$cmd}};
193         my $str = $class->usage_str($name, "$exename $cmd", $arg_param, $uri_param, 'short', $pwcallback, $stringfilemap);
194         print $fd "\n" if $oldclass && $oldclass ne $class;
195         print $fd "       $str";
196         $oldclass = $class;
197     }
198 }
199
200 my $print_bash_completion = sub {
201     my ($simple_cmd, $bash_command, $cur, $prev) = @_;
202
203     my $debug = 0;
204
205     return if !(defined($cur) && defined($prev) && defined($bash_command));
206     return if !defined($ENV{COMP_LINE});
207     return if !defined($ENV{COMP_POINT});
208
209     my $cmdline = substr($ENV{COMP_LINE}, 0, $ENV{COMP_POINT});
210     print STDERR "\nCMDLINE: $ENV{COMP_LINE}\n" if $debug;
211
212     my $args = PVE::Tools::split_args($cmdline);
213     my $pos = scalar(@$args) - 2;
214     $pos += 1 if $cmdline =~ m/\s+$/;
215
216     print STDERR "CMDLINE:$pos:$cmdline\n" if $debug;
217
218     return if $pos < 0;
219
220     my $print_result = sub {
221         foreach my $p (@_) {
222             print "$p\n" if $p =~ m/^$cur/;
223         }
224     };
225
226     my $cmd;
227     if ($simple_cmd) {
228         $cmd = $simple_cmd;
229     } else {
230         if ($pos == 0) {
231             &$print_result(keys %$cmddef);
232             return;
233         }
234         $cmd = $args->[1];
235     }
236
237     my $def = $cmddef->{$cmd};
238     return if !$def;
239
240     print STDERR "CMDLINE1:$pos:$cmdline\n" if $debug;
241
242     my $skip_param = {};
243
244     my ($class, $name, $arg_param, $uri_param) = @$def;
245     $arg_param //= [];
246     $uri_param //= {};
247
248     $arg_param = [ $arg_param ] if !ref($arg_param);
249
250     map { $skip_param->{$_} = 1; } @$arg_param;
251     map { $skip_param->{$_} = 1; } keys %$uri_param;
252
253     my $fpcount = scalar(@$arg_param);
254
255     my $info = $class->map_method_by_name($name);
256
257     my $schema = $info->{parameters};
258     my $prop = $schema->{properties};
259
260     my $print_parameter_completion = sub {
261         my ($pname) = @_;
262         my $d = $prop->{$pname};
263         if ($d->{completion}) {
264             my $vt = ref($d->{completion});
265             if ($vt eq 'CODE') {
266                 my $res = $d->{completion}->($cmd, $pname, $cur, $args);
267                 &$print_result(@$res);
268             }
269         } elsif ($d->{type} eq 'boolean') {
270             &$print_result('0', '1');
271         } elsif ($d->{enum}) {
272             &$print_result(@{$d->{enum}});
273         }
274     };
275
276     # positional arguments
277     $pos += 1 if $simple_cmd;
278     if ($fpcount && $pos <= $fpcount) {
279         my $pname = $arg_param->[$pos -1];
280         &$print_parameter_completion($pname);
281         return;
282     }
283
284     my @option_list = ();
285     foreach my $key (keys %$prop) {
286         next if $skip_param->{$key};
287         push @option_list, "--$key";
288     }
289
290     if ($cur =~ m/^-/) {
291         &$print_result(@option_list);
292         return;
293     }
294
295     if ($prev =~ m/^--?(.+)$/ && $prop->{$1}) {
296         my $pname = $1;
297         &$print_parameter_completion($pname);
298         return;
299     }
300
301     &$print_result(@option_list);
302 };
303
304 sub verify_api {
305     my ($class) = @_;
306
307     # simply verify all registered methods
308     PVE::RESTHandler::validate_method_schemas();
309 }
310
311 my $get_exe_name = sub {
312     my ($class) = @_;
313
314     my $name = $class;
315     $name =~ s/^.*:://;
316     $name =~ s/_/-/g;
317
318     return $name;
319 };
320
321 sub generate_bash_completions {
322     my ($class) = @_;
323
324     # generate bash completion config
325
326     $exename = &$get_exe_name($class);
327
328     print <<__EOD__;
329 # $exename bash completion
330
331 # see http://tiswww.case.edu/php/chet/bash/FAQ
332 # and __ltrim_colon_completions() in /usr/share/bash-completion/bash_completion
333 # this modifies global var, but I found no better way
334 COMP_WORDBREAKS=\${COMP_WORDBREAKS//:}
335
336 complete -o default -C '$exename bashcomplete' $exename
337 __EOD__
338 }
339
340 sub generate_asciidoc_synopsys {
341     my ($class) = @_;
342     $class->generate_asciidoc_synopsis();
343 };
344
345 sub generate_asciidoc_synopsis {
346     my ($class) = @_;
347
348     $cli_handler_class = $class;
349
350     $exename = &$get_exe_name($class);
351
352     no strict 'refs';
353     my $def = ${"${class}::cmddef"};
354     $cmddef = $def;
355
356     if (ref($def) eq 'ARRAY') {
357         print_simple_asciidoc_synopsis(@$def);
358     } else {
359         $cmddef->{help} = [ __PACKAGE__, 'help', ['cmd'] ];
360
361         print_asciidoc_synopsis();
362     }
363 }
364
365 # overwrite this if you want to run/setup things early
366 sub setup_environment {
367     my ($class) = @_;
368
369     # do nothing by default
370 }
371
372 my $handle_cmd  = sub {
373     my ($args, $pwcallback, $preparefunc, $stringfilemap) = @_;
374
375     $cmddef->{help} = [ __PACKAGE__, 'help', ['cmd'] ];
376
377     # call verifyapi before setup_environment(), because we do not want to
378     # execute any real code in this case
379
380     my $cmd = shift @$args;
381     if (!$cmd) {
382         print_usage_short (\*STDERR, "no command specified");
383         exit (-1);
384     } elsif ($cmd eq 'verifyapi') {
385         PVE::RESTHandler::validate_method_schemas();
386         return;
387     }
388
389     $cli_handler_class->setup_environment();
390
391     if ($cmd eq 'bashcomplete') {
392         &$print_bash_completion(undef, @$args);
393         return;
394     }
395
396     &$preparefunc() if $preparefunc;
397
398     $cmd = &$expand_command_name($cmddef, $cmd);
399
400     my ($class, $name, $arg_param, $uri_param, $outsub) = @{$cmddef->{$cmd} || []};
401
402     if (!$class) {
403         print_usage_short (\*STDERR, "unknown command '$cmd'");
404         exit (-1);
405     }
406
407     my $prefix = "$exename $cmd";
408     my $res = $class->cli_handler($prefix, $name, \@ARGV, $arg_param, $uri_param, $pwcallback, $stringfilemap);
409
410     &$outsub($res) if $outsub;
411 };
412
413 my $handle_simple_cmd = sub {
414     my ($args, $pwcallback, $preparefunc, $stringfilemap) = @_;
415
416     my ($class, $name, $arg_param, $uri_param, $outsub) = @{$cmddef};
417     die "no class specified" if !$class;
418
419     if (scalar(@$args) >= 1) {
420         if ($args->[0] eq 'help') {
421             my $str = "USAGE: $name help\n";
422             $str .= $class->usage_str($name, $name, $arg_param, $uri_param, 'long', $pwcallback, $stringfilemap);
423             print STDERR "$str\n\n";
424             return;
425         } elsif ($args->[0] eq 'verifyapi') {
426             PVE::RESTHandler::validate_method_schemas();
427             return;
428         }
429     }
430
431     $cli_handler_class->setup_environment();
432
433     if (scalar(@$args) >= 1) {
434         if ($args->[0] eq 'bashcomplete') {
435             shift @$args;
436             &$print_bash_completion($name, @$args);
437             return;
438         }
439     }
440
441     &$preparefunc() if $preparefunc;
442
443     my $res = $class->cli_handler($name, $name, \@ARGV, $arg_param, $uri_param, $pwcallback, $stringfilemap);
444
445     &$outsub($res) if $outsub;
446 };
447
448 sub run_cli_handler {
449     my ($class, %params) = @_;
450
451     $cli_handler_class = $class;
452
453     $ENV{'PATH'} = '/sbin:/bin:/usr/sbin:/usr/bin';
454
455     foreach my $key (keys %params) {
456         next if $key eq 'prepare';
457         next if $key eq 'no_init'; # not used anymore
458         next if $key eq 'no_rpcenv'; # not used anymore
459         die "unknown parameter '$key'";
460     }
461
462     my $preparefunc = $params{prepare};
463
464     my $pwcallback = $class->can('read_password');
465     my $stringfilemap = $class->can('string_param_file_mapping');
466
467     $exename = &$get_exe_name($class);
468
469     initlog($exename);
470
471     no strict 'refs';
472     $cmddef = ${"${class}::cmddef"};
473
474     if (ref($cmddef) eq 'ARRAY') {
475         &$handle_simple_cmd(\@ARGV, $pwcallback, $preparefunc, $stringfilemap);
476     } else {
477         &$handle_cmd(\@ARGV, $pwcallback, $preparefunc, $stringfilemap);
478     }
479
480     exit 0;
481 }
482
483 1;