* fix `lei q -tt' on locally-indexed messages (still broken for remotes:
https://public-inbox.org/meta/20230226170931.M947721@dcvr/ )
- * `lei import' now set labels+keywords consistently on all
+ * `lei import' now sets labels+keywords consistently on all
already-imported messages
solver (used by lei (rediff|blob), and PublicInbox::WWW)
* incron - run commands based on filesystem events: http://incron.aiken.cz/
-* sendmail / MTA - we use and recommend use postfix, which includes a
+* sendmail / MTA - we use and recommend postfix, which includes a
sendmail-compatible wrapper: http://www.postfix.org/
* spamc / spamd - SpamAssassin: http://spamassassin.apache.org/
There is no need to ask the NSA for backups of your mail archives :)
* git, one of the most widely-used version control systems, includes many
- tools for for email, including: git-format-patch(1), git-send-email(1),
+ tools for email, including: git-format-patch(1), git-send-email(1),
git-am(1), git-imap-send(1). Furthermore, the development of git itself
is based on the git mailing list: https://public-inbox.org/git/
(or
http://4uok3hntl7oi7b4uf4rtfwefqeexfzil2w6kgk2jn5z2f764irre7byd.onion/git/
- for Tor users)
+ for Tor users).
* Email is already the de-facto form of communication in many Free Software
- communities..
+ communities.
* Fallback/transition to private email and other lists, in case the
public-inbox host becomes unavailable, users may still directly email
* As of 2016, git is widely used and known to nearly all Free Software
developers. For non-developers it is packaged for all major GNU/Linux
- and *BSD distributions. NNTP is not as widely-used nowadays, and
+ and *BSD distributions. NNTP is not as widely used nowadays, and
most IMAP clients do not have good support for read-only mailboxes.
Why perl 5?
-----------
-* Perl 5 is widely available on modern *nix systems with good a history
+* Perl 5 is widely available on modern *nix systems, with a good history
of backwards and forward compatibility.
* git and SpamAssassin both use it, so it should be one less thing for
We favor <pre>-formatted text since public-inbox is intended as a place
to share and discuss patches and code. Unfortunately, long paragraphs
-tends to be less readable with fixed-width serif fonts which GUI
+tend to be less readable with fixed-width serif fonts which GUI
browsers default to.
* No graphics, images, or icons at all. We tolerate, but do not
avoided as they do not render well with some displays or user-chosen
fonts.
-* No JavaScript. JS is historically too buggy and insecure, and we will
+* No JavaScript. JS is historically too buggy and insecure, and we will
never expect our readers to do either of the following:
- a) read and audit all our code for on every single page load
- b) trust us and and run code without reading it
+ a) read and audit all our code on every single page load
+ b) trust us and run code without reading it
-* We only use CSS for one reason: wrapping pre-formatted text
+* We only use CSS for one reason: wrapping pre-formatted text.
This is necessary because unfortunate GUI browsers tend to be
prone to layout widening from unwrapped mailers.
Do not expect CSS to be enabled, especially with scary things like:
-----------------------------------
See examples in contrib/css/ and lib/PublicInbox/WwwText.pm
-(or https://public-inbox.org/meta/_/text/color/ soon)
+(or <https://public-inbox.org/meta/_/text/color/>)
=head1 FILES
-By default storage is located at C<$XDG_DATA_HOME/lei/store>. The
+By default, storage is located at C<$XDG_DATA_HOME/lei/store>. The
configuration for lei resides at C<$XDG_CONFIG_HOME/lei/config>.
=head1 ERRORS
The local path name of a CSS file for the PSGI web interface.
May contain the attributes "media", "title" and "href" which match
the associated attributes of the HTML <style> tag.
-"href" may be specified to point to the URL of an remote CSS file
+"href" may be specified to point to the URL of a remote CSS file
and the path may be "/dev/null" or any empty file.
Multiple files may be specified and will be included in the
order specified.
=item publicinbox.cgitdata
A path to the data directory used by cgit for storing static files.
-Typically guessed based the location of C<cgit.cgi> (from
-C<publicinbox.cgitbin>, but may be overridden.
+Typically guessed based on the location of C<cgit.cgi> (from
+C<publicinbox.cgitbin>), but may be overridden.
-Default:
basename of C<publicinbox.cgitbin>, /var/www/htdocs/cgit/
+Default:
dirname of C<publicinbox.cgitbin>, /var/www/htdocs/cgit/
or /usr/share/cgit/
=item publicinbox.cgit
=item * fallback
Fall back to using C<cgit> only if our native, inbox-aware
-git code repository viewer doesn't recognized the URL.
+git code repository viewer doesn't recognize the URL.
=item * rewrite
The default TLS certificate for HTTPS, IMAPS, NNTPS, POP3S and/or STARTTLS
support if the C<cert> option is not given with C<--listen>.
+=for comment FIXME this paragraph needs repair
+
Well-known TCP ports automatically get TLS or STARTTLS support
If using systemd-compatible socket activation and a TCP listener
on port well-known ports (563 is inherited, it is automatically
The default TLS certificate key for the default C<--cert> or
per-listener C<cert=> option. The private key may be
-concatenated into the path used by the cert, in which case this
+concatenated into the cert file itself, in which case this
option is not needed.
=item --multi-accept INTEGER
-By default, each worker accepts one connection at-a-time to maximize
+By default, each worker accepts one connection at a time to maximize
fairness and minimize contention across multiple processes on a
shared listen socket. Accepting multiple connections at once may be
-useful in constrained deployments with few, heavily-loaded workers.
+useful in constrained deployments with few, heavily loaded workers.
Negative values enables a worker to accept all available clients at
once, possibly starving others in the process. C<-1> behaves like
C<multi_accept yes> in nginx; while C<0> (the default) is
=head1 SIGNALS
Most of our signal handling behavior is copied from L<nginx(8)>
-and/or L<starman(1)>; so it is possible to reuse common scripts
+and/or L<starman(1)>, so it is possible to reuse common scripts
for managing them.
=over 8
=item SIGTTIN
-Increase the number of running workers processes by one.
+Increase the number of running worker processes by one.
=item SIGTTOU
=item SIGWINCH
-Stop all running worker processes. SIGHUP or SIGTTIN
+Stop all running worker processes. SIGHUP or SIGTTIN
may be used to restart workers.
=item SIGQUIT
=item PERL_INLINE_DIRECTORY
-Pointing this to point to a writable directory enables the use
+Pointing this to a writable directory enables the use
of L<Inline> and L<Inline::C> extensions which may provide
platform-specific performance improvements. Currently, this
enables the use of L<vfork(2)> which speeds up subprocess
There are two ways to upgrade a running process.
Users of process management systems with socket activation
-(L<systemd(1)> or similar) may rely on multiple instances For
-systemd, this means using two (or more) '@' instances for each
+(L<systemd(1)> or similar) may rely on multiple daemon instances.
+For systemd, this means using two (or more) '@' instances for each
service (e.g. C<SERVICENAME@INSTANCE>) as documented in
L<systemd.unit(5)>.
=item tid, THREADID
-A sequentially-assigned positive integer. These integers are
+A sequentially assigned positive integer. These integers are
per-inbox or per-extindex. In the future, this may be prefixed
with C<T> for JMAP (RFC 8621) and RFC 8474. This may not be
strictly compliant with RFC 8621 since inboxes and extindices
=item IMAP EMAILID, JMAP Email Id
-To-be-decided. This will likely be the git blob ID prefixed with C<g>
+To be decided. This will likely be the git blob ID prefixed with C<g>
rather than the numeric UID to accommodate the same blob showing
up in both an extindex and inbox (or multiple extindices).
For L<lei(1)> users only. This will allow lei users to place
the same email into one or more virtual folders for
-ease-of-filtering. This is NOT tied to public-inbox names, as
+ease of filtering. This is NOT tied to public-inbox names, as
messages stored by lei may not be public.
These are similar in spirit to arbitrary freeform "tags"
not feed the message to L<spamc(1)> and only removes messages
which match on any of the C<To:>, C<Cc:>, and C<List-ID:> headers.
-The C<--all> option may be used match C<spam> semantics in removing
+The C<--all> option may be used to match C<spam> semantics in removing
the message from all configured inboxes. C<--all> is only
available in public-inbox 1.6.0+.
=head1 COPYRIGHT
-Copyright 2019-2021 all contributors L<mailto:meta@public-inbox.org>
+Copyright all contributors L<mailto:meta@public-inbox.org>
License: AGPL-3.0+ L<https://www.gnu.org/licenses/agpl-3.0.txt>
=item --all
Purge the message in all inboxes configured in ~/.public-inbox/config.
-This is an alternative to specifying individual inboxes directories
+This is an alternative to specifying individual inbox directories
on the command-line.
=back
=head1 COPYRIGHT
-Copyright 2019-2021 all contributors L<mailto:meta@public-inbox.org>
+Copyright all contributors L<mailto:meta@public-inbox.org>
License: AGPL-3.0+ L<https://www.gnu.org/licenses/agpl-3.0.txt>
slowdowns as inboxes grow.
While C<-V2> introduced Xapian shards as a parallelization
-mechanism for SSDs
; enabling C<publicInbox.indexSequentialShard>
-repurposes sharding as mechanism to reduce the kernel page cache
+mechanism for SSDs
, enabling C<publicInbox.indexSequentialShard>
+repurposes sharding as a mechanism to reduce the kernel page cache
footprint when indexing on HDDs.
Initializing a mirror with a high C<--jobs> count to create more
Disabling copy-on-write also disables checksumming, thus C<raid1>
(or higher) configurations may be corrupt after unsafe shutdowns.
-Fortunately, these SQLite and Xapian indices are designed to
+Fortunately, these SQLite and Xapian indices are designed to be
recoverable from git if missing.
Disabling CoW does not prevent all fragmentation. Large values
Large filesystems benefit significantly from the C<space_cache=v2>
mount option documented in L<btrfs(5)>.
-Older, non-CoW filesystems are generally work well out-of-the-box
+Older, non-CoW filesystems generally work well out of the box
for our Xapian and SQLite indices.
=head2 Performance on solid state drives
accommodate many concurrent clients.
Transport Layer Security (IMAPS, NNTPS, or via STARTTLS) significantly
-increases memory use of client sockets, sure to account for that in
+increases memory use of client sockets, be sure to account for that in
capacity planning.
=head2 Other OS tuning knobs
L<public-inbox-extindex(1)> allows any number of public-inboxes
to share the same Xapian indices.
-git 2.33+ startup time is orders-of-magnitude faster and uses
+git 2.33+ startup time is orders of magnitude faster and uses
less memory when dealing with thousands of alternates required
for thousands of inboxes with L<public-inbox-extindex(1)>.
- all.git # empty, alternates to $EPOCH.git
- xap$SCHEMA_VERSION/$SHARD # per-shard Xapian DB
- xap$SCHEMA_VERSION/over.sqlite3 # OVER-view DB for NNTP, threading
- - msgmap.sqlite3 # same the v1 msgmap
+ - msgmap.sqlite3 # same as the v1 msgmap
For blob lookups, the reader only needs to open the "all.git"
repository with $GIT_DIR/objects/info/alternates which references
messages written to 'd' after they are written to 'm'.
Deltafication is not significantly improved over v1, but overall
-storage for trees is made as as small as possible. Initial
+storage for trees is made as small as possible. Initial
statistics and benchmarks showing the benefits of this approach
are documented at:
=head2 XAPIAN SHARDS
-Another second scalability problem in v1 was the inability to
+Another scalability problem in v1 was the inability to
utilize multiple CPU cores for Xapian indexing. This is
addressed by using shards in Xapian to perform import
indexing in parallel.
public-inbox-watch is useful in situations when a user wishes to
mirror an existing mailing list, but has no access to run
L<public-inbox-mda(1)> on a server. Unlike public-inbox-mda
-which is invoked once per-message, public-inbox-watch is a
+which is invoked once per message, public-inbox-watch is a
persistent process, making it faster for after-the-fact imports
of large Maildirs.
=head1 CONFIGURATION
These configuration knobs should be used in the
-L<public-inbox-config(5)> file
+L<public-inbox-config(5)> file.
=over 8
Keeping all communications as email ensures the full history
of the entire project can be mirrored by anyone with the
resources to do so. Compact, low-complexity data requires
-less resources to mirror, so sticking with plain-text
+less resources to mirror, so sticking with plain text
ensures more parties can mirror and potentially fork the
project with all its data.
uncomfortable, good. That was the point. It's how checks
and balances ought to work.
-Comments, corrections, etc welcome: meta@public-inbox.org
+Comments, corrections, etc. welcome: meta@public-inbox.org
intends to implement. This list is intended to be a quick reference
for hackers and users.
-Given the goals of interoperability and accessibility; strict
+Given the goals of interoperability and accessibility, strict
conformance to standards is not always possible, but rather
best-effort taking into account real-world cases. In particular,
"obsolete" standards remain relevant as long as clients and
-data exists.
+data using them exist.
IETF RFCs
---------
Common abbreviation: $mime, $eml
Used by: PublicInbox::WWW, PublicInbox::SearchIdx
- An representation of an entire email, multipart or not.
+ A representation of an entire email, multipart or not.
An option to use libgmime or libmailutils may be supported
in the future for performance and memory use.
This can be a memory hog with big messages and giant
attachments, so our PublicInbox::WWW interface only keeps
- one object of this class in memory at-a-time.
+ one object of this class in memory at a time.
In other words, this is the "meat" of the message, whereas
$smsg (below) is just the "skeleton".
Our PublicInbox::V2Writable class may have two objects of this
- type in memory at-a-time for deduplication.
+ type in memory at a time for deduplication.
In public-inbox 1.4 and earlier, Email::MIME and its subclass,
PublicInbox::MIME were used. Despite still slurping,
This is loaded from either the overview DB (over.sqlite3) or
the Xapian DB (docdata.glass), though the Xapian docdata
- is won't hold NNTP-only fields (Cc:/To:)
+ won't hold NNTP-only fields (Cc:/To:).
There may be hundreds or thousands of these objects in memory
- at-a-time, so fields are pruned if unneeded.
+ at a time, so fields are pruned if unneeded.
* PublicInbox::SearchThread::Msg - subclass of Smsg
Common abbreviation: $cont or $node
Nowadays, this is a re-blessed $smsg with additional fields.
As with $smsg objects, there may be hundreds or thousands
- of these objects in memory at-a-time.
+ of these objects in memory at a time.
- We also do not use a linked-list for storing children as JWZ
+ We also do not use a linked list for storing children as JWZ
describes, but instead a Perl hashref for {children} which
becomes an arrayref upon sorting.
* PublicInbox::Inbox - represents a single public-inbox
Common abbreviation: $ibx
- Used everywhere
+ Used everywhere.
This represents a "publicinbox" section in the config
file, see public-inbox-config(5) for details.
This holds the PSGI $env as well as any internal variables
used by various modules of PublicInbox::WWW.
- As with the PSGI $env, there is one per-active WWW
+ As with the PSGI $env, there is one per active WWW
request+response cycle. It does not exist for idle HTTP
clients.
Common abbreviation: $http
Used by: PublicInbox::DS, public-inbox-httpd
- Unlike PublicInbox::NNTP, this class no knowledge of any of
- the email or git-specific parts of public-inbox, only PSGI.
+ Unlike PublicInbox::NNTP, this class has no knowledge of any of
+ the email- or git-specific parts of public-inbox, only PSGI.
However, it supports APIs and behaviors (e.g. streaming large
responses) which PublicInbox::WWW may take advantage of.
This class calls non-blocking accept(2) or accept4(2) on a
listen socket to create new PublicInbox::HTTP and
- PublicInbox::HTTP instances.
+ PublicInbox::NNTP instances.
* PublicInbox::HTTPD
Common abbreviation: $httpd
wrappers around client sockets accepted from
PublicInbox::Listener.
- Since the SERVER_NAME and SERVER_PORT PSGI variables needs to be
+ Since the SERVER_NAME and SERVER_PORT PSGI variables need to be
exposed for HTTP/1.0 requests when Host: headers are missing,
- this is per-Listener socket.
+ this is per Listener socket.
* PublicInbox::HTTPD::Async
Common abbreviation: $async
triggers a call.
The lack of read/write callback distinction is driven by the
- fact TLS libraries (e.g. OpenSSL via IO::Socket::SSL) may
+ fact that TLS libraries (e.g. OpenSSL via IO::Socket::SSL) may
declare SSL_WANT_READ on SSL_write(), and SSL_WANT_READ on
SSL_read(). So we end up having to let each user object decide
whether it wants to make read or write calls depending on its
Reducing the user-supplied code down to a single callback allows
subclasses to keep their logic self-contained. The combination
of this change and one-shot wakeups (see below) for bidirectional
- data flows make asynchronous code easier to reason about.
+ data flows makes asynchronous code easier to reason about.
Other divergences:
Augmented features:
-* obj->write(CODEREF) passes the object itself to the CODEREF
+* obj->write(CODEREF) passes the object itself to the CODEREF.
Being able to enqueue subroutine calls is a powerful feature in
Danga::Socket for keeping linear logic in an asynchronous environment.
Unfortunately, each subroutine takes several kilobytes of memory.
We strive to keep processes small to improve locality, allow
the kernel to cache more files, and to be a good neighbor to
other processes running on the machine. Taking advantage of
-automatic reference counting (ARC) in Perl allows us
+automatic reference counting (ARC) in Perl allows us to
deterministically release memory back to the heap.
We start with a simple data model with few circular
Perl 5 is installed on many, if not most GNU/Linux and
BSD-based servers and workstations. It is likely the most
- widely-installed programming environment that offers a
+ widely installed programming environment that offers a
significant amount of POSIX functionality. Users won't
have to waste bandwidth or space with giant toolchains or
architecture-specific binaries.
* Predictable performance
- While Perl is neither fast or memory-efficient, its
- performance and memory use are predictable and does not
+ While Perl is neither fast nor memory-efficient, its
+ performance and memory use are predictable and do not
require GC tuning by the user.
public-inbox is developed for (and mostly on) old
late 1990s, and any cheap VPS today has more than enough
RAM and CPU for handling plain-text email.
- Low hardware requirements increases the reach of our software
+ Low hardware requirements increase the reach of our software
to more users, improving centralization resistance.
* Compatibility
There should be no need to rely on language-specific
package managers such as cpan(1), those systems increase
- the learning curve for users and systems administrators.
+ the learning curve for users and system administrators.
* Compactness and terseness
* Performance ceiling and escape hatch
With optional Inline::C, we can be "as fast as C" in some
- cases. Inline::C is widely-packaged by distros and it
+ cases. Inline::C is widely packaged by distros and it
gives us an escape hatch for dealing with missing bindings
or performance problems should they arise. Inline::C use
(as opposed to XS) also preserves the software freedom and
(m//, substr(), index(), etc.) still require memory copies
into userspace, negating a benefit of zero-copy.
-* The XS/C API make it difficult to improve internals while
+* The XS/C API makes it difficult to improve internals while
preserving compatibility.
* Lack of optional type checking. This may be a blessing in
-----------------------------------------------------
These don't discount a language or runtime from being
-being used, they're just not interesting.
+used, they're just not interesting.
* Lightweight threading
While lightweight threading implementations are
- convenient, they tend to be significantly heavier than a
+ convenient, they tend to be significantly heavier than
pure event-loop systems (or multi-threaded event-loop
- systems)
+ systems).
Lightweight threading implementations have stack overhead
and growth typically measured in kilobytes. The userspace
and http://4uok3hntl7oi7b4uf4rtfwefqeexfzil2w6kgk2jn5z2f764irre7byd.onion/meta/ (using Tor)
Contributions are email-driven, just like contributing to git
-itself or the Linux kernel; however anonymous and pseudonymous
+itself or the Linux kernel; nevertheless, anonymous and pseudonymous
contributions will always be welcome.
Please consider our goals in mind:
Decentralization, Accessibility, Compatibility, Performance
These goals apply to everyone: users viewing over the web or NNTP,
-sysadmins running public-inbox, and other hackers working public-inbox.
+sysadmins running public-inbox, and other hackers working on public-inbox.
We will reject any feature which advocates or contributes to any
-particular instance of a public-inbox becoming a single point of failure.
+particular instance of public-inbox becoming a single point of failure.
Things we've considered but rejected include:
* exposing article serial numbers outside of NNTP
* allowing readers to inject metadata (e.g. votes)
We care about being accessible to folks with vision problems and/or
-lack the computing resources to view so-called "modern" websites.
+lacking the computing resources to view so-called "modern" websites.
This includes folks on slow connections and ancient browsers which
may be too difficult to upgrade due to resource demands.
Do not recurse on user-supplied data. Neither Perl or C handle
deep recursion gracefully. See lib/PublicInbox/SearchThread.pm
and lib/PublicInbox/MsgIter.pm for examples of non-recursive
-alternatives to previously-recursive algorithms.
+alternatives to previously recursive algorithms.
Performance should be reasonably good for server administrators, too,
and we will sacrifice features to achieve predictable performance.
Optional packages for testing and development
---------------------------------------------
-Optional packages testing and development:
-
- Plack::Test deb: libplack-test-perl
pkg: p5-Plack
rpm: perl-Plack-Test
----------
* \w, \s, \d character classes all match Unicode characters;
- so write out class ranges (e.g "[0-9]") if you only intend to
+ so write out class ranges (e.g., "[0-9]") if you only intend to
match ASCII. Do not use the "/a" (ASCII) modifier, that requires
Perl 5.14 and we're only depending on 5.10.1 at the moment.
public-inbox (server-side) installation
---------------------------------------
-This is for folks who want to setup their own public-inbox instance.
+This is for folks who want to set up their own public-inbox instance.
Clients should use normal git-clone/git-fetch, IMAP or NNTP clients
if they want to import mail into their personal inboxes.
foreground servers)
The following module is typically pulled in by dependencies listed
-above, so there is no need to explicitly install them:
+above, so there is no need to explicitly install it:
- DBI deb: libdbi-perl
pkg: p5-DBI
communication. Users may have broken graphics drivers, limited
eyesight, or be unable to afford modern hardware.
-public-inbox aims to be easy-to-deploy and manage; encouraging projects
+public-inbox aims to be easy to deploy and manage, encouraging projects
to run their own instances with minimal overhead.
Implementation
in https://public-inbox.org/public-inbox-v2-format.txt and
https://public-inbox.org/public-inbox-v1-format.txt
-By storing (and optionally) exposing an inbox via git, it is
+By storing and (optionally) exposing an inbox via git, it is
fast and efficient to host and mirror public-inboxes.
Traditional mailing lists use the "push" model. For readers,
If a reader loses interest, they simply stop following.
-Since we use git, mirrors are easy-to-setup, and lists are
-easy-to-relocate to different mail addresses without losing
+Since we use git, mirrors are easy to set up, and lists are
+easy to relocate to different mail addresses without losing
or splitting archives.
-_Anybody_ may also setup a delivery-only mailing list server to
+_Anybody_ may also set up a delivery-only mailing list server to
replay a public-inbox git archive to subscribers via SMTP.
Features
Please Cc: all recipients when replying as we do not require
subscription. This also makes it easier to rope in folks of
-tangentially related projects we depend on (e.g. git developers
+tangentially related projects we depend on (e.g., git developers
on git@vger.kernel.org).
The archives are readable via IMAP, NNTP or HTTP:
as mail is archived forever.
As of the 2010s, successful online social networks and forums are the
-ones which heavily restrict users formatting options; so public-inbox
-aims to preserve the focus on content, and not presentation.
+ones which heavily restrict users' formatting options; public-inbox
+aims to preserve the focus on content, not presentation.
Copyright
---------
TODO items for public-inbox
(Not in any particular order, and
-performance, ease-of-setup, installation, maintainability, etc
-all need to be considered for everything we introduce)
+performance, ease of setup, installation, maintainability, etc.
+all need to be considered for everything we introduce.)
* general performance improvements, but without relying on
XS or pre-built modules any more than we currently do.
portability to older Linux, free BSDs and maybe Hurd).
* dogfood latest Xapian, Perl5, SQLite, git and various modules to
- ensure things continue working as they should (or more better)
+ ensure things continue working as they should (or better)
while retaining compatibility with old versions.
* Support more of RFC 3977 (NNTP)
or doing development. However, it can be convenient to for
users to mass-install several packages.
-* ci/profiles.sh - prints to-be tested package profile for the current OS
+* ci/profiles.sh - prints to-be-tested package profile for the current OS
Called automatically by ci/run.sh
The output is read by ci/run.sh
# Copyright (C) 2019-2021 all contributors <meta@public-inbox.org>
# License: AGPL-3.0+ <https://www.gnu.org/licenses/agpl-3.0.txt>
-# Prints OS-specific package profiles to stdout (one per-newline) to use
+# Prints OS-specific package profiles to stdout (one per line) to use
# as command-line args for ci/deps.perl. Called automatically by ci/run.sh
# set by os-release(5) or similar
-scripts use for public-inbox development that don't belong in t/
+scripts used for public-inbox development that don't belong in t/
}
sub vcl_pipe {
- # By default Connection: close is set on all piped requests by varnish,
+ # By default, Connection: close is set on all piped requests by varnish,
# but public-inbox-httpd supports persistent connections well :)
unset bereq.http.connection;
return (pipe);
warn "E: awaitpid($pid): $@" if $@;
}
-# This relies on our Perl process is single-threaded, or at least
-# no threads are spawning and waiting on processes (``, system(), etc...)
+# This relies on our Perl process being single-threaded, or at least
+# no threads spawning and waiting on processes (``, system(), etc...)
# Threads are officially discouraged by the Perl5 team, and I expect
# that to remain the case.
sub reap_pids {
-l ADDRESS address to listen on$dh
--cert=FILE default SSL/TLS certificate
- --key=FILE default SSL/TLS certificate
+ --key=FILE default SSL/TLS certificate key
-W WORKERS number of worker processes to spawn (default: 1)
See public-inbox-daemon(8) and $prog(1) man pages for more.
root/ - files for system-wide use (plugins, rule definitions,
new rules should have a zero score which should be overridden)
user/ - per-user config (keep as much in here as possible)
- These files go into the users home directory
+ These files go into the user's home directory.
-All files in these example directory are CC0:
+All files in these example directories are CC0:
To the extent possible under law, Eric Wong has waived all copyright and
related or neighboring rights to these examples.
use PublicInbox::InboxWritable;
use PublicInbox::Spamcheck;
-# n.b: hopefully we can setup the emergency path without bailing due to
-# user error, we really want to setup the emergency destination ASAP
+# n.b.: Hopefully we can set up the emergency path without bailing due to
+# user error, we really want to set up the emergency destination ASAP
# in case there's bugs in our code or user error.
my $emergency = $ENV{PI_EMERGENCY} || "$ENV{HOME}/.public-inbox/emergency/";
$ems = PublicInbox::Emergency->new($emergency);
This directory contains informal scripts and random tools used
-in the development of public-inbox. Some only exist only for
+in the development of public-inbox. Some only exist for
historical purposes, and some may not work anymore.
See the "script/" directory (not "scripts/") for supported and
projects / thirdparty / public-inbox.git / commitdiff
