Synchronized Gopherholes (18-1-11)

   Happy New Year, by the way, and a warning upfront: the following post
   is mostly an outline of an idea!

   Although I had vacation over the holidays, I was totally inactive on
   the phlogging side. Family consumed quite some of my time (in a good
   way though), and I was not that motivated anyway, although I partly
   followed the activity on SDF.

   With the recent hiccups on SDF, I was thinking about where best to
   establish one's [ph|g|b]log presence to be least affected by downtime.
   Nothing's forever, though, and so one could establish a system of
   interconnected gopherholes which automatically synchronize their
   contents, and publish all the locations so that people could look
   elsewhere, if one node goes down. Actually it's not restricted to blogs
   etc, but one's online presence in general.

   Of course neither the problem nor ideas to solve it are anything new.
   Think about torrents, or solutions like the [1]InterPlanetary File
   System, [2]Freenet, [3]zeronet etc. The problem with these systems is
   the requirement to install some specific client or to use some kind of
   gateway. I want a solution working with normal clients, especially for
   gopher.

   In principle, this might be accomplished by dynamic DNS or even a Round
   Robin DNS system. However, that's again a single point of failure:
   recently, some of my solutions temporarily broke because of mdns.org
   (hosted by SDF) being offline.

   In total, it boils down to "search all places where stuff could be and
   try to connect to them" which must be done either by a client (zeronet
   etc) or by the audience themselves (publish a set of entry points to
   the same content on different servers, and people try to find a working
   one). Currently, I don't want to use the former approach, and therefore
   a package for easy installation of a synchronization system seems the
   best solution. Obviously, the servers themselvesmcould well use some of
   the former systems in the background for their synchronization.

   As my [4]plog suite already contains code for git-based handling of
   source texts and publication into websites and gopher directories, it
   might be a good starting point. The final goal is an interconnected
   system of servers providing the following:
     * source texts can be injected into any running server, and after
       some hours, every other running server updates to the new content
     * conflicts, e.g new texts from different servers, are handled
       automatically (git should mostly do this already, with some
       additional script logic)
     * each server runs a web and gopher server, automatically generates
       its static pages from source texts, and may also run mailinglists
       (like already implemented in plog -- but there is a problem to
       solve, as only one e-mail per post and recipient should be sent)
     * source texts can generate plog entries, but may also update
       existing pages for managing synchronized static sites (web and
       gopher)
     * servers coming up after being offline try to find another server
       for updating themselves, and if a new server is added to the swarm,
       this information is automatically shared among the others, i.e a
       server only needs to know about a single one and will learn from it
       about the others

   Perhaps I should rewrite the plog suite; currently it's a bit messy, as
   the functional parts are rather intermingled. It might be better to
   have separate scripts or functions for (git) synchronization, source
   text conversion, publication, and mailing.

   Actually, it might even be best to completely separate the git
   synchronisation logic from all the other components, because it could
   be used for any kind of content like private repos, backups etc.

   Anyway, we'll see which goals I'll manage to implement in the near
   future!

   .:.

References

   1. https://ipfs.io/
   2. https://freenetproject.org/
   3. https://zeronet.io/
   4. https://gitlab.com/yargo/plog