]> Sergey Matveev's repositories - public-inbox.git/commitdiff
lei up: support --all for IMAP folders
authorEric Wong <e@80x24.org>
Tue, 7 Sep 2021 11:32:10 +0000 (11:32 +0000)
committerEric Wong <e@80x24.org>
Tue, 7 Sep 2021 13:30:50 +0000 (13:30 +0000)
Since "lei up" is expected to be a heavily-used command,
better support for IMAP seems like a reasonable idea.

This is inefficient since we waste an IMAP(S) TCP connection
since it dies when an auth-only LeiUp worker process dies, but
it's better than not working at all, right now.

Documentation/lei-up.pod
lib/PublicInbox/LEI.pm
lib/PublicInbox/LeiAuth.pm
lib/PublicInbox/LeiToMail.pm
lib/PublicInbox/LeiUp.pm
xt/net_writer-imap.t

index cea0f61924ebffe9968fe5ede416259192ee987c..ca4cf4fee78c8a57e609e6dd48ecfc16f7cc1750 100644 (file)
@@ -6,15 +6,24 @@ lei-up - update a saved search
 
 lei up [OPTIONS] OUTPUT
 
 
 lei up [OPTIONS] OUTPUT
 
-lei up [OPTIONS] --all=TYPE
+lei up [OPTIONS] --all[=<local|remote>]
 
 =head1 DESCRIPTION
 
 
 =head1 DESCRIPTION
 
-Update the saved search at C<OUTPUT> or all saved searches of C<TYPE>
-(currently C<local> is the only supported value).
+Update the saved search at C<OUTPUT> or all saved searches.
 
 =head1 OPTIONS
 
 
 =head1 OPTIONS
 
+=over
+
+=item --all[=<local|remote>]
+
+C<--all> updates all saved searches (listed in L<lei-ls-search(1)>).
+C<--all=local> only updates local mailboxes, C<--all=remote> only
+updates remote mailboxes (currently C<imap://> and C<imaps://>).
+
+=back
+
 The following options, described in L<lei-q(1)>, are supported.
 
 =over
 The following options, described in L<lei-q(1)>, are supported.
 
 =over
index bd44cfaeb662046377b58dec6cda9a4af4bc8311..a258722e04d582724e567011aabd6c321e16c3a7 100644 (file)
@@ -605,16 +605,19 @@ sub incr {
        $self->{counters}->{$field} += $nr;
 }
 
        $self->{counters}->{$field} += $nr;
 }
 
+sub pkt_ops {
+       my ($lei, $ops) = @_;
+       $ops->{'!'} = [ \&fail_handler, $lei ];
+       $ops->{'|'} = [ \&sigpipe_handler, $lei ];
+       $ops->{x_it} = [ \&x_it, $lei ];
+       $ops->{child_error} = [ \&child_error, $lei ];
+       $ops->{incr} = [ \&incr, $lei ];
+       $ops;
+}
+
 sub workers_start {
        my ($lei, $wq, $jobs, $ops, $flds) = @_;
 sub workers_start {
        my ($lei, $wq, $jobs, $ops, $flds) = @_;
-       $ops = {
-               '!' => [ \&fail_handler, $lei ],
-               '|' => [ \&sigpipe_handler, $lei ],
-               'x_it' => [ \&x_it, $lei ],
-               'child_error' => [ \&child_error, $lei ],
-               'incr' => [ \&incr, $lei ],
-               ($ops ? %$ops : ()),
-       };
+       $ops = pkt_ops($lei, { ($ops ? %$ops : ()) });
        $ops->{''} //= [ $wq->can('_lei_wq_eof') || \&wq_eof, $lei ];
        my $end = $lei->pkt_op_pair;
        my $ident = $wq->{-wq_ident} // "lei-$lei->{cmd} worker";
        $ops->{''} //= [ $wq->can('_lei_wq_eof') || \&wq_eof, $lei ];
        my $end = $lei->pkt_op_pair;
        my $ident = $wq->{-wq_ident} // "lei-$lei->{cmd} worker";
index 465a2758466851321c996189f79c30a22b06746d..9b09cecf05cb1f6b54a86720cf695d34d0b75f07 100644 (file)
@@ -30,10 +30,16 @@ sub do_auth_atfork { # used by IPC WQ workers
        return if $wq->{-wq_worker_nr} != 0; # only first worker calls this
        my $lei = $wq->{lei};
        my $net = $lei->{net};
        return if $wq->{-wq_worker_nr} != 0; # only first worker calls this
        my $lei = $wq->{lei};
        my $net = $lei->{net};
+       if ($net->{-auth_done}) { # from previous worker... (ugly)
+               $lei->{pkt_op_p}->pkt_do('net_merge_continue', $net) or
+                               $lei->fail("pkt_do net_merge_continue: $!");
+               return;
+       }
        eval { # fill auth info (may prompt user or read netrc)
                my $mics = $net->imap_common_init($lei);
                my $nn = $net->nntp_common_init($lei);
                # broadcast successful auth info to lei-daemon:
        eval { # fill auth info (may prompt user or read netrc)
                my $mics = $net->imap_common_init($lei);
                my $nn = $net->nntp_common_init($lei);
                # broadcast successful auth info to lei-daemon:
+               $net->{-auth_done} = 1;
                $lei->{pkt_op_p}->pkt_do('net_merge_continue', $net) or
                                die "pkt_do net_merge_continue: $!";
                $net->{mics_cached} = $mics if $mics;
                $lei->{pkt_op_p}->pkt_do('net_merge_continue', $net) or
                                die "pkt_do net_merge_continue: $!";
                $net->{mics_cached} = $mics if $mics;
@@ -51,14 +57,15 @@ sub net_merge_all { # called in wq worker via wq_broadcast
 # called by top-level lei-daemon when first worker is done with auth
 # passes updated net auth info to current workers
 sub net_merge_continue {
 # called by top-level lei-daemon when first worker is done with auth
 # passes updated net auth info to current workers
 sub net_merge_continue {
-       my ($wq, $net_new) = @_;
+       my ($wq, $lei, $net_new) = @_;
+       $wq->{-net_new} = $net_new; # for "lei up"
        $wq->wq_broadcast('PublicInbox::LeiAuth::net_merge_all', $net_new);
        $wq->wq_broadcast('PublicInbox::LeiAuth::net_merge_all', $net_new);
-       $wq->net_merge_all_done; # defined per-WQ
+       $wq->net_merge_all_done($lei); # defined per-WQ
 }
 
 sub op_merge { # prepares PktOp->pair ops
 }
 
 sub op_merge { # prepares PktOp->pair ops
-       my ($self, $ops, $wq) = @_;
-       $ops->{net_merge_continue} = [ \&net_merge_continue, $wq ];
+       my ($self, $ops, $wq, $lei) = @_;
+       $ops->{net_merge_continue} = [ \&net_merge_continue, $wq, $lei ];
 }
 
 sub new { bless \(my $x), __PACKAGE__ }
 }
 
 sub new { bless \(my $x), __PACKAGE__ }
index 2c7a92de2130ff232c6f5580dbf87524ac5db003..01f083844d136954b86efe48ddab689c5e953c9d 100644 (file)
@@ -396,7 +396,8 @@ sub new {
        } elsif ($fmt =~ /\Aimaps?\z/) {
                require PublicInbox::NetWriter;
                require PublicInbox::URIimap;
        } elsif ($fmt =~ /\Aimaps?\z/) {
                require PublicInbox::NetWriter;
                require PublicInbox::URIimap;
-               my $net = PublicInbox::NetWriter->new;
+               # {net} may exist from "lei up" for auth
+               my $net = $lei->{net} // PublicInbox::NetWriter->new;
                $net->{quiet} = $lei->{opt}->{quiet};
                my $uri = PublicInbox::URIimap->new($dst)->canonical;
                $net->add_url($$uri);
                $net->{quiet} = $lei->{opt}->{quiet};
                my $uri = PublicInbox::URIimap->new($dst)->canonical;
                $net->add_url($$uri);
index a39d6047a26cab1c5e7db999271118f5b513aabe..30358e9da0fc96e0f93f86e8812861a7ba377813 100644 (file)
@@ -5,8 +5,14 @@
 package PublicInbox::LeiUp;
 use strict;
 use v5.10.1;
 package PublicInbox::LeiUp;
 use strict;
 use v5.10.1;
+# n.b. we use LeiInput to setup IMAP auth
+use parent qw(PublicInbox::IPC PublicInbox::LeiInput);
 use PublicInbox::LeiSavedSearch;
 use PublicInbox::LeiSavedSearch;
-use parent qw(PublicInbox::IPC);
+use PublicInbox::DS;
+use PublicInbox::PktOp;
+use PublicInbox::LeiFinmsg;
+use PublicInbox::LEI;
+my $REMOTE_RE = qr!\A(?:imap|http)s?://!i; # http(s) will be for JMAP
 
 sub up1 ($$) {
        my ($lei, $out) = @_;
 
 sub up1 ($$) {
        my ($lei, $out) = @_;
@@ -48,75 +54,95 @@ sub up1 ($$) {
 
 sub up1_redispatch {
        my ($lei, $out, $op_p) = @_;
 
 sub up1_redispatch {
        my ($lei, $out, $op_p) = @_;
-       require PublicInbox::LeiFinmsg;
-       $lei->{fmsg} //= PublicInbox::LeiFinmsg->new($lei->{2});
        my $l = bless { %$lei }, ref($lei);
        $l->{opt} = { %{$l->{opt}} };
        my $l = bless { %$lei }, ref($lei);
        $l->{opt} = { %{$l->{opt}} };
-       delete $l->{sock};
-       $l->{''} = $op_p; # daemon only
+       delete $l->{sock}; # do not close
+       $l->{''} = $op_p; # daemon only ($l => $lei => script/lei)
 
        # make close($l->{1}) happy in lei->dclose
        open my $fh, '>&', $l->{1} or return $l->child_error(0, "dup: $!");
 
        # make close($l->{1}) happy in lei->dclose
        open my $fh, '>&', $l->{1} or return $l->child_error(0, "dup: $!");
+       local $PublicInbox::LEI::current_lei = $l;
        $l->{1} = $fh;
        eval {
                $l->qerr("# updating $out");
                up1($l, $out);
        $l->{1} = $fh;
        eval {
                $l->qerr("# updating $out");
                up1($l, $out);
-               $l->qerr("# $out done");
        };
        };
-       $l->child_error(0, $@) if $@;
+       $lei->child_error(0, $@) if $@ || $l->{failed}; # lei->fail()
+}
+
+sub redispatch_all ($$) {
+       my ($self, $lei) = @_;
+       # re-dispatch into our event loop w/o creating an extra fork-level
+       $lei->{fmsg} = PublicInbox::LeiFinmsg->new($lei->{2});
+       my ($op_c, $op_p) = PublicInbox::PktOp->pair;
+       for my $o (@{$self->{local} // []}, @{$self->{remote} // []}) {
+               PublicInbox::DS::requeue(sub {
+                       up1_redispatch($lei, $o, $op_p);
+               });
+       }
+       $lei->event_step_init;
+       $lei->pkt_ops($op_c->{ops} = { '' => [$lei->can('dclose'), $lei] });
 }
 
 sub lei_up {
        my ($lei, @outs) = @_;
 }
 
 sub lei_up {
        my ($lei, @outs) = @_;
-       $lei->{lse} = $lei->_lei_store(1)->search;
        my $opt = $lei->{opt};
        my $opt = $lei->{opt};
-       my @local;
-       if (defined $opt->{all}) {
+       my $self = bless { -mail_sync => 1 }, __PACKAGE__;
+       $lei->{lse} = $lei->_lei_store(1)->write_prepare($lei)->search;
+       if (defined(my $all = $opt->{all})) {
                return $lei->fail("--all and @outs incompatible") if @outs;
                length($opt->{mua}//'') and return
                        $lei->fail('--all and --mua= are incompatible');
                return $lei->fail("--all and @outs incompatible") if @outs;
                length($opt->{mua}//'') and return
                        $lei->fail('--all and --mua= are incompatible');
-
-               # supporting IMAP outputs is more involved due to
-               # git-credential prompts.  TODO: add this in 1.8
-               $opt->{all} eq 'local' or return
-                       $lei->fail('only --all=local works at the moment');
-               my @all = PublicInbox::LeiSavedSearch::list($lei);
-               @local = grep(!m!\Aimaps?://!i, @all);
+               @outs = PublicInbox::LeiSavedSearch::list($lei);
+               if ($all eq 'local') {
+                       $self->{local} = [ grep(!/$REMOTE_RE/, @outs) ];
+               } elsif ($all eq 'remote') {
+                       $self->{remote} = [ grep(/$REMOTE_RE/, @outs) ];
+               } elsif ($all eq '') {
+                       $self->{remote} = [ grep(/$REMOTE_RE/, @outs) ];
+                       $self->{local} = [ grep(!/$REMOTE_RE/, @outs) ];
+               } else {
+                       $lei->fail("only --all=$all not understood");
+               }
        } else {
        } else {
-               @local = @outs;
+               $self->{remote} = [ grep(/$REMOTE_RE/, @outs) ];
+               $self->{local} = [ grep(!/$REMOTE_RE/, @outs) ];
        }
        }
-       if (scalar(@outs) > 1) {
-               length($opt->{mua}//'') and return $lei->fail(<<EOM);
+       ((@{$self->{local} // []} + @{$self->{remote} // []}) > 1 &&
+               length($opt->{mua} // '')) and return $lei->fail(<<EOM);
 multiple outputs and --mua= are incompatible
 EOM
 multiple outputs and --mua= are incompatible
 EOM
-               # TODO:
-               return $lei->fail(<<EOM) if grep(m!\Aimaps?://!i, @outs);
-multiple destinations only supported for local outputs (FIXME)
-EOM
+       if ($self->{remote}) { # setup lei->{auth}
+               $self->prepare_inputs($lei, $self->{remote}) or return;
        }
        }
-       if (scalar(@local) > 1) {
-               $lei->_lei_store->write_prepare($lei); # share early
-               # daemon mode, re-dispatch into our event loop w/o
-               # creating an extra fork-level
-               require PublicInbox::DS;
-               require PublicInbox::PktOp;
-               my ($op_c, $op_p) = PublicInbox::PktOp->pair;
-               for my $o (@local) {
-                       PublicInbox::DS::requeue(sub {
-                               up1_redispatch($lei, $o, $op_p);
-                       });
-               }
-               $lei->event_step_init;
-               $op_c->{ops} = { '' => [$lei->can('dclose'), $lei] };
+       if ($lei->{auth}) { # start auth worker
+               require PublicInbox::NetWriter;
+               bless $lei->{net}, 'PublicInbox::NetWriter';
+               $lei->{auth}->op_merge(my $ops = {}, $self, $lei);
+               (my $op_c, $ops) = $lei->workers_start($self, 1, $ops);
+               $lei->{wq1} = $self;
+               $lei->wait_wq_events($op_c, $ops);
+               # net_merge_all_done will fire when auth is done
        } else {
        } else {
-               up1($lei, $local[0]);
+               redispatch_all($self, $lei); # see below
        }
 }
 
        }
 }
 
+# called in top-level lei-daemon when LeiAuth is done
+sub net_merge_all_done {
+       my ($self, $lei) = @_;
+       $lei->{net} = delete($self->{-net_new}) if $self->{-net_new};
+       $self->wq_close(1);
+       redispatch_all($self, $lei);
+}
+
 sub _complete_up {
        my ($lei, @argv) = @_;
        my $match_cb = $lei->complete_url_prepare(\@argv);
        map { $match_cb->($_) } PublicInbox::LeiSavedSearch::list($lei);
 }
 
 sub _complete_up {
        my ($lei, @argv) = @_;
        my $match_cb = $lei->complete_url_prepare(\@argv);
        map { $match_cb->($_) } PublicInbox::LeiSavedSearch::list($lei);
 }
 
+no warnings 'once';
+*ipc_atfork_child = \&PublicInbox::LeiInput::input_only_atfork_child;
+
 1;
 1;
index aeed314499642e09d0ce7ca167e026078dfa7273..0a4cea68d5002210f2afd8c47745623e3e41ac81 100644 (file)
@@ -242,6 +242,7 @@ EOM
 
        lei_ok qw(q m:testmessage --no-external -o), $folder_url;
        lei_ok qw(up), $folder_url;
 
        lei_ok qw(q m:testmessage --no-external -o), $folder_url;
        lei_ok qw(up), $folder_url;
+       lei_ok qw(up --all=remote);
 });
 
 undef $cleanup; # remove temporary folder
 });
 
 undef $cleanup; # remove temporary folder