user/dev discussion of public-inbox itself
 help / color / mirror / code / Atom feed
4637cb46a28f5968d63bee430eb3fdd18773b4e7 blob 5116 bytes (raw)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# Copyright (C) 2021 all contributors <meta@public-inbox.org>
# License: AGPL-3.0+ <https://www.gnu.org/licenses/agpl-3.0.txt>

# "lei up" - updates the result of "lei q --save"
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::DS;
use PublicInbox::PktOp;
use PublicInbox::LeiFinmsg;
my $REMOTE_RE = qr!\A(?:imap|http)s?://!i; # http(s) will be for JMAP

sub up1 ($$) {
	my ($lei, $out) = @_;
	my $lss = PublicInbox::LeiSavedSearch->up($lei, $out) or return;
	my $f = $lss->{'-f'};
	my $mset_opt = $lei->{mset_opt} = { relevance => -2 };
	$mset_opt->{limit} = $lei->{opt}->{limit} // 10000;
	my $q = $mset_opt->{q_raw} = $lss->{-cfg}->{'lei.q'} //
				return $lei->fail("lei.q unset in $f");
	my $lse = $lei->{lse} // die 'BUG: {lse} missing';
	if (ref($q)) {
		$mset_opt->{qstr} = $lse->query_argv_to_string($lse->git, $q);
	} else {
		$lse->query_approxidate($lse->git, $mset_opt->{qstr} = $q);
	}
	my $o = $lei->{opt}->{output} = $lss->{-cfg}->{'lei.q.output'} //
		return $lei->fail("lei.q.output unset in $f");
	ref($o) and return $lei->fail("multiple values of lei.q.output in $f");
	if (defined(my $dd = $lss->{-cfg}->{'lei.q.dedupe'})) {
		$lss->translate_dedupe($lei, $dd) or return;
		$lei->{opt}->{dedupe} = $dd;
	}
	for my $k (qw(only include exclude)) {
		my $v = $lss->{-cfg}->get_all("lei.q.$k") // next;
		$lei->{opt}->{$k} = $v;
	}
	for my $k (qw(external local remote
			import-remote import-before threads)) {
		my $c = "lei.q.$k";
		my $v = $lss->{-cfg}->{$c} // next;
		ref($v) and return $lei->fail("multiple values of $c in $f");
		$lei->{opt}->{$k} = $v;
	}
	$lei->{lss} = $lss; # for LeiOverview->new
	my $lxs = $lei->lxs_prepare or return;
	$lei->ale->refresh_externals($lxs, $lei);
	$lei->_start_query;
}

sub up1_redispatch {
	my ($lei, $out, $op_p) = @_;
	my $l;
	if (defined($lei->{opt}->{mua})) { # single output
		$l = $lei;
	} else { # multiple outputs
		$l = bless { %$lei }, ref($lei);
		$l->{opt} = { %{$l->{opt}} }; # deep copy
		delete $l->{opt}->{all};
		delete $l->{sock}; # do not close
		# make close($l->{1}) happy in lei->dclose
		open my $fh, '>&', $l->{1} or
			return $l->child_error(0, "dup: $!");
		$l->{1} = $fh;
		$l->qerr("# updating $out");
	}
	$l->{''} = $op_p; # daemon only ($l => $lei => script/lei)
	eval { $l->dispatch('up', $out) };
	$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);
	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) = @_;
	my $opt = $lei->{opt};
	my $self = bless { -mail_sync => 1 }, __PACKAGE__;
	if (defined(my $all = $opt->{all})) {
		return $lei->fail("--all and @outs incompatible") if @outs;
		defined($opt->{mua}) and return
			$lei->fail('--all and --mua= are incompatible');
		@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");
		}
	} elsif ($lei->{lse}) {
		scalar(@outs) == 1 or die "BUG: lse set w/ >1 out[@outs]";
		return up1($lei, $outs[0]);
	} else {
		$self->{remote} = [ grep(/$REMOTE_RE/, @outs) ];
		$self->{local} = [ grep(!/$REMOTE_RE/, @outs) ];
	}
	$lei->{lse} = $lei->_lei_store(1)->write_prepare($lei)->search;
	((@{$self->{local} // []} + @{$self->{remote} // []}) > 1 &&
		defined($opt->{mua})) and return $lei->fail(<<EOM);
multiple outputs and --mua= are incompatible
EOM
	if ($self->{remote}) { # setup lei->{auth}
		$self->prepare_inputs($lei, $self->{remote}) or return;
	}
	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 {
		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);
}

no warnings 'once';
*ipc_atfork_child = \&PublicInbox::LeiInput::input_only_atfork_child;

1;
debug log:

solving 4637cb46 ...
found 4637cb46 in https://80x24.org/public-inbox.git

Code repositories for project(s) associated with this inbox:

	https://80x24.org/public-inbox.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).