source: trunk/LATMOS-Accounts/lib/LATMOS/Accounts/Cli.pm @ 2419

Last change on this file since 2419 was 2419, checked in by nanardon, 4 years ago

la-cli: search return an error is object type is unsupported
  • Property svn:keywords set to Id
File size: 15.8 KB
Line 
1package LATMOS::Accounts::Cli;
2
3# $Id: Cli.pm 2145 2018-08-29 18:15:46Z nanardon $
4
5use strict;
6use warnings;
7use Moose;
8use LATMOS::Accounts::Log;
9use LATMOS::Accounts::Utils;
10use Term::ReadLine;
11use Text::ParseWords;
12use Getopt::Long;
13use LATMOS::Accounts::Cli::Object;
14
15extends 'LATMOS::Accounts::Cli::Base';
16
17=head1 NAME
18
19LATMOS::Accounts::Cli - Command line interface functions
20
21=head1 DESCRIPTION
22
23This module handle envirronment and functons for L<la-cli> tools.
24
25=cut
26
27=head1 FUNCTIONS
28
29=cut
30
31=head2 globalenv
32
33Return the main envirronement object
34
35=cut
36
37sub _create_from_handle {
38    my ($self, $fh, $otype, $objname) = @_;
39
40    my $labase = $self->base;
41
42    my %attr = LATMOS::Accounts::Utils::parse_obj_file($fh);
43    if ($objname && (my $obj = $labase->get_object($otype, $objname))) {
44         warn "Object $otype $objname already exists, aborting\n";
45         return;
46    } else {
47        if ($objname) {
48            my $res = $labase->create_c_object($otype, $objname, %attr);
49            if($res) {
50                $self->print("Changes applied\n");
51                $labase->commit;
52                return 1;
53            }
54            return 0;
55        } else {
56            my $ochelper = $labase->ochelper($otype);
57
58            my $info = {
59                contents => { %attr },
60            };
61            if ($attr{name}) {
62                $info->{name}{content} = $attr{name};
63            }
64
65            $ochelper->Automate($info) or do {
66                warn "Cannot create object:" . LATMOS::Accounts::Log::lastmessage() . "\n";
67                return;
68            };
69            return 1;
70        } 
71    }
72}
73
74=head1 CLI FUNCTIONS
75
76=head2 GLOBAL FUNCTIONS
77
78=cut
79
80sub BUILD {
81    my ( $self ) = @_;
82
83    my $labase = $self->base;
84
85    $self->add_func('ls', {
86            help => 'ls object_type - list object of type object_type', 
87            completion => sub {
88                if(!$_[2]) {
89                    return $_[0]->base->list_supported_objects
90                } else { () }
91            },
92            code => sub {
93                my $env = shift;
94                my @args = $self->getoption(
95                    {
96                        'fmt=s'      => \my $fmt,
97                        'filefmt=s'  => \my $filefmt,
98                    }, @_
99                );
100
101                my $otype = $args[0] or do {
102                    $self->print("Object type missing\n");
103                    return 1;
104                };
105
106                if ($filefmt){
107                    open(my $hfmt, '<', $filefmt) or do {
108                       warn "Cannot open $filefmt\n";
109                       return;
110                    };
111                    $fmt ||= ''; # avoid undef warning
112                    while (<$hfmt>) {
113                        chomp($fmt .= $_);
114                    }
115                    close $hfmt;
116                }
117
118                if ($fmt) {
119                    foreach ($env->base->list_objects($otype)) {
120                        my $obj = $env->base->get_object($otype, $_) or next;
121                        $self->print($obj->queryformat($fmt));
122                    }
123                    $self->print("\n");
124                } else {
125                    $self->print(map { "$_\n" } $env->base->list_objects($otype));
126                }
127            },
128        });
129    $self->add_func('search', {
130            help => 'search objecttype filter1 [filter2...] - search object according filter',
131            completion => sub {
132                my ($self, $ritem, $rotype) = @_;
133                if(!$_[2]) {
134                    return $self->base->list_supported_objects
135                } else {
136                    my $parse;
137                    $parse = sub {
138                        my ($otype, $item) = @_;
139                        $item ||= '';
140                        my ($NegFilter, $attr, $dot, $attrref, $operator, $val) = $item =~ /^([\!\+\-]?)(\w+)(?:(\.)([\.\w]+))?(?:([^\w*]+)(.+))?$/;
141                        if ($dot) {
142                            my $attribute = $self->base->attribute($otype, $attr) or
143                                return ($self->base->list_canonical_fields( $otype, 'r' ) );
144                            my $refotype  = $attribute->reference;
145                            return map { "$attr." . $_ } $parse->($refotype, "$attrref$operator$val" );
146                        } else {
147                            return($self->base->list_canonical_fields($otype, 'r'));
148                        }
149
150                    };
151                    return(
152                        map { $_, "!$_", "-$_", "+$_" }
153                        map { ( $_ . '=', $_ . '~' ) } $parse->( $rotype, $ritem )
154                    );
155                }
156            },
157            code => sub {
158                my ($self, @args) = @_;
159                if ($args[0]) {
160                    if (!$self->base->is_supported_object($args[0])) {
161                        $self->print("$args[0] is an usupported object type\n");
162                    } else {
163                        my @res = $self->base->search_objects(@args);
164                        $self->print(map { "$_\n" } @res);
165                        $self->{_lastsearch} = \@res;
166                        $self->{_lastsearchtype} = $args[0];
167                    }
168                } else {
169                    $self->print("Object type missing\n");
170                }
171            },
172        });
173    $self->add_func('expired', {
174        help => 'expired [delay] - list expired account more than delay (default is now)',
175        code => sub {
176            my ($self, $expire) = @_;
177            my @users = $self->base->find_expired_users($expire);
178            $self->print(map { "$_\n" } @users);
179            $self->{_lastsearchtype} = 'user';
180            $self->{_lastsearch} = \@users;
181        },
182    }) if ($self->base->can('find_expired_users'));
183    $self->add_func('expires', {
184        help => 'expires [delay] - list account expiring before delay (default is 1 month)',
185        code => sub {
186            my ($self, $expire) = @_;
187            my @users = $self->base->find_next_expire_users($expire);
188            $self->print(map { "$_\n" } @users);
189            $self->{_lastsearchtype} = 'user';
190            $self->{_lastsearch} = \@users;
191        },
192    }) if ($self->base->can('find_next_expire_users'));
193    $self->add_func('select', {
194            help => 'select object_type - select objects to perform action on it',
195            completion => sub {
196                if ($_[2]) {
197                    return $_[0]->base->list_objects($_[2]);
198                } else {
199                    return '@', $_[0]->base->list_supported_objects;
200                }
201            },
202            code => sub {
203                my ($self, $otype, @ids) = @_;
204                my @objs;
205                if ($otype eq '@') {
206                    if (@{$self->{_lastsearch} || []}) {
207                        $otype = $self->{_lastsearchtype};
208                        @ids = @{$self->{_lastsearch}};
209                    } else {
210                        $self->print("No results store from previous search\n");
211                        return;
212                    }
213                }
214                if (!@ids) {
215                    $self->print('not enough arguments' . "\n");
216                    return;
217                }
218                foreach (@ids) {
219                    my $obj = $self->base->get_object($otype, $_) or do {
220                        $self->print("Cannot get $otype $_\n");
221                        return;
222                    };
223                    push(@objs, $obj);
224                }
225                $self->print("Selecting $otype " . join(', ', @ids) . "\n");
226                LATMOS::Accounts::Cli::Object->new(
227                    Parent  => $self,
228                    Context => $self->Context,
229                    otype   => $otype,
230                    objs    => \@objs,
231                )->cli();
232            },
233        });
234
235=head3 create
236
237Create object
238
239
240=over 4
241
242=item -i
243
244    interactive: will prompt for attribute
245
246=item -f FILE
247
248    Read file for attribute value
249
250=item -e
251
252    open an epty file instead instead attribute list
253
254=item --ro
255
256    Open an empty with attribute even read-only one
257
258=back
259
260=cut
261
262    $self->add_func('create', {
263            code => sub {
264                my $self = shift;
265                my ($otype, $objname) = $self->getoption(
266                    {
267                        'i'   => \my $interactive,
268                        'f=s' => \my $inputfile,
269                        'ro'  => \my $with_ro,
270                        'e'   => \my $empty_file,
271                    }, @_
272                );
273
274                if ( $interactive ) {
275                    my $helper = $self->base->ochelper($otype);
276                    my $info = undef;
277                    while (1) {
278                        my $status;
279                        ($status, $info) = $helper->step($info);
280
281                        if ($status ne 'NEEDINFO') {
282                            if ($status eq 'CREATED') {
283                                $self->print("Object created\n");
284                                $self->commit;
285                            } else {
286                                $self->print("Nothing done\n");
287                                $self->rollback;
288                            }
289                            return;
290                        }
291
292                        if ($info->{name}{ask}) {
293                            my $line = $self->Context->Term->readline("Name of the object ?");
294                            $info->{name}{content} = $line;
295                        }
296                        foreach my $attr (@{$info->{ask} || []}) {
297                            $self->Context->Term->Attribs->{completion_function} = sub {
298                                $info->{contents}{$attr}
299                            };
300                            my $line = $self->Context->Term->readline(sprintf('  %s %s? ',
301                                    $attr,
302                                    $info->{contents}{$attr}
303                                    ? '(' . $info->{contents}{$attr} . ') '
304                                    : ''
305                                ));
306                            $info->{contents}{$attr} = $line if($line);
307                        }
308                    }
309                } elsif ($inputfile) {
310                    my $handle;
311                    open($handle, '<', $inputfile) or do {
312                        warn "Cannot open input file $@\n";
313                        return;
314                    };
315                    my $res = $self->_create_from_handle($handle, $otype, $objname);
316                    close($handle);
317                    $self->commit if($res);
318                    return($res);
319                } else {
320                    return LATMOS::Accounts::Utils::dump_read_temp_file(
321                        sub {
322                            my ($fh) = @_;
323                            $labase->text_empty_dump($fh, $otype,
324                                {
325                                    only_rw => !$with_ro,
326                                }
327                            ) unless($empty_file);
328                        },
329                        sub {
330                            my ($fh) = @_;
331                            if (my $res = $self->_create_from_handle($fh, $otype, $objname)) {
332                                 $self->commit;
333                                 return $res;
334                             } else {
335                                 return;
336                             }
337                        }
338                    );
339                }
340            },
341            completion => sub {
342                my ($self, $carg, @args) = @_;
343                my @options = ();
344                push( @options, qw(-i -f)  ) unless ( grep { $_ =~ /^-[fi]$/ } @args );
345                push( @options, qw(-e --ro)) unless ( grep { $_ eq '-f' } @args );
346
347                if (($args[-1] || '') eq '-f') {
348                    my $attribs = $self->Context->Term->Attribs;
349                    return $self->Context->Term->completion_matches($carg, $attribs->{'filename_completion_function'});
350                } else {
351                    return (@options, $self->base->list_supported_objects);
352                }
353            },
354        }
355    );
356    $self->add_func('exchangeip', 
357        {
358            help => 'Exchange two IP on host',
359            code => sub {
360                my ($self, @args) = @_;
361                my ($ip1, $ip2) =
362                    grep { $_ && $_ =~ /\d+\.\d+\.\d+\.\d+/ } @args;
363                if (!$ip2) {
364                    $self->print("Need two ip to exchange\n");
365                    return;
366                }
367                if ($self->base->nethost_exchange_ip($ip1, $ip2)) {
368                    $self->print("$ip1 and $ip2 get exchange\n");
369                    $self->commit;
370                } else {
371                    $self->rollback;
372                }   
373            },
374            completion => sub {
375                my ($self, $carg, @args) = @_;
376                if ($args[-1] && $args[-1] !~ m/\d+\.\d+\.\d+\.\d+/) {
377                    if (my $obj = $self->base->get_object('nethost', $args[-1])) {
378                        return $obj->get_attributes('ip');
379                    }
380                } else {
381                    my @list = 
382                    ($self->base->attributes_summary('nethost', 'ip'),
383                        $self->base->list_objects('nethost'));
384                    return @list;
385                }
386            },
387        }
388    );
389
390    $self->add_func('loadcsv',
391        {
392            help => 'Load CSV file to create object',
393            code => sub {
394                my ($self, $otype, $file) = @_;
395
396                open(my $fh, '<', $file) or do {
397                   warn "Cannot open  $file $!\n";
398                   return;
399                };
400
401                my @ids;
402
403                loadCSV(
404                    $fh,
405                    cb => sub {
406                        my ($res, $linecount) = @_;
407
408                        my $ochelper = $labase->ochelper($otype);
409
410                        my $info = {
411                            contents => $res
412                        };
413                        if ($res->{name}) {
414                            $info->{name}{content} = $res->{name};
415                        }
416
417                        if (my $id = $ochelper->Automate($info)) {
418                            push(@ids, $id);
419                        } else {
420                            warn "Cannot create object line $linecount (not enough information ?)\n";
421                        }
422                    },
423                );
424
425                close($fh);
426
427                my @objs;
428                foreach (@ids) {
429                    my $obj = $self->base->get_object($otype, $_) or do {
430                        $self->print("Cannot get $otype $_\n");
431                        return;
432                    };
433                    push(@objs, $obj);
434                }
435
436                $self->print("Selecting $otype " . join(', ', @ids) . "\n");
437                LATMOS::Accounts::Cli::Object->new(
438                    Parent  => $self,
439                    Context => $self->Context,
440                    otype   => $otype,
441                    objs    => \@objs,
442                )->cli();
443            },
444            completion => sub {
445                if ($_[2]) {
446                    return Term::ReadLine::Gnu::filename_list(@_);
447                } else {
448                    return '@', $_[0]->base->list_supported_objects;
449                }
450            },
451        }
452    );
453
454    $self->add_func('user',  { alias => [qw'select user' ] });
455    $self->add_func('group', { alias => [qw'select group'] });
456    return $self
457}
458
4591;
460
461__END__
462
463=head1 SEE ALSO
464
465L<LATMOS::Accounts>
466
467=head1 AUTHOR
468
469Olivier Thauvin, E<lt>olivier.thauvin@latmos.ipsl.frE<gt>
470
471=head1 COPYRIGHT AND LICENSE
472
473Copyright (C) 2008, 2009, 2010, 2011, 2012 CNRS SA/CETP/LATMOS
474
475This library is free software; you can redistribute it and/or modify
476it under the same terms as Perl itself, either Perl version 5.10.0 or,
477at your option, any later version of Perl 5 you may have available.
478
479=cut
Note: See TracBrowser for help on using the repository browser.