Package: plotmanx
Xman: another Chia plotting managerThis is a tool for managingChiaplotting operations.  The tool runs on the plotting machine and provides
the following functionality:Automatic spawning of new plotting jobs, possibly overlapping ("staggered")
on multiple temp directories, rate-limited globally and by per-temp-dir
limits.Rsync'ing of newly generated plots to a remote host (a farmer/harvester),
called "archiving".Monitoring of ongoing plotting and archiving jobs, progress, resources used,
temp files, etc.Control of ongoing plotting jobs (suspend, resume, plus kill and clean up
temp files).Both an interactive live dashboard mode as well as command line mode tools.(very alpha) Analyzing performance statistics of past jobs, to aggregate on
various plotting parameters or temp dir type.Plotman is designed for the following configuration:A plotting machine with an array oftmpdirs, a singletmp2dir, and an
array ofdstdirs to which the plot jobs plot.  Thedstdirs serve as a
temporary buffer space for generated plots.A farming machine with a large number of drives, made accessible via anrsyncdmodule, and to be entirely populated with plots.  These are known as
thearchivedirectories.Plot jobs are run with STDOUT/STDERR redirected to a log file in a configured
directory.  This allows analysis of progress (plot phase) as well as timing
(e.g. for analyzing performance).FunctionalityPlotman tools are stateless.  Rather than keep an internal record of what jobs
have been started, Plotman relies on the process tables, open files, and
logfiles of plot jobs to understand "what's going on".  This means the tools
can be stopped and started, even from a different login session, without loss
of information.  It also means Plotman can see and manage jobs started manually
or by other tools, as long as their STDOUT/STDERR redirected to a file in a
known logfile directory.  (Note: The tool relies on reading the chia plot
command line arguments and the format of the plot tool output.  Changes in
those may break this tool.)Plot scheduling is done by waiting for a certain amount of wall time since the
last job was started, finding the best (e.g. least recently used)tmpdir for
plotting, and ensuring that job has progressed to at least a certain point
(e.g., phase 2, subphase 5).Plots are output to thedstdirs, which serve as a temporary buffer until they
are rsync'd ("archived") to the farmer/harvester.  The archiver does several
things to attempt to avoid concurrent IO.  First, it only allows one rsync
process at a time (more sophisticated scheduling could remove this
restriction, but it's nontrivial).  Second, it inspects the pipeline of plot
jobs to see whichdstdirs are about to have plots written to them.  This
is balanced against how full thedstdrives are in a priority scheme.It is, obviously, necessary that your rsync bandwidth exceeds your plotting
bandwidth.  Given this, in normal operation, thedstdirs remain empty until
a plot is finished, after which it is shortly thereafter picked up by the
archive job.  However, the decoupling provided by usingdstdrives as a
buffer means that should the farmer/harvester or the network become
unavailable, plotting continues uninterrupted.Screenshot OverviewThe screenshot shows some of the main features of Plotman.The first line shows the status.  The plotting status shows whether we just
started a plot, or, if not, why not (e.g., stagger time, tmp directories being
ready, etc.; in this case, the 1800s stagger between plots has not been reached
yet).  Archival status says whether we are currently archiving (and provides
thersyncpid) or whether there are no plots available in thedstdrives to
archive.The second line provides a key to some directory abbrevations used throughout.
Fortmpanddstdirectories, we assume they have a common prefix, which is
computed and indicated here, after which they can be referred to (in context)
by their unique suffix.  For example, if we havetmpdirs/mnt/tmp/00,/mnt/tmp/01,/mnt/tmp/02, etc., we show/mnt/tmpas the prefix here and
can then talk abouttmpdirs00or01etc.  Thearchivedirectories are
the same except that these are paths on a remote host and accessed via anrsyncdmodule (seesrc/plotman/resources/plotman.yamlfor details).The next table shows information about the active plotting jobs.  It is
abbreviated to show the most and least recently started jobs (the full list is
available via the command line mode).  It shows various information about the
plot jobs, including the plot ID (first 8 chars), the directories used,
walltime, the current plot phase and subphase, space used on thetmpdrive,
pid, etc.The next tables are a bit hard to read; there is actually atmptable on the
left which is split into two tables for rendering purposes, and adsttable
on the right.  Thetmptables show the phases of the plotting jobs using
them, and whether or not they're ready to take a new plot job.  Thedsttable
shows how many plots have accumulated, how much free space is left, and the
phases of jobs that are destined to write to them, and finally, the priority
computed for the archive job to move the plots away.The last table simply shows free space of drives on the remote
harverster/farmer.Finally, the last section shows a log of actions performed -- namely, plot and
archive jobs initiated.  This is the one part of the interactive tool which is
stateful.  There is no permanent record of these executed command lines, so if
you start a new interactive plotman session, this log is empty.Limitations and IssuesThe system is tested on Linux only.  Plotman should be generalizable to other
platforms, but this is not done yet.  Some of the issues around making calls
out to command line programs (e.g., runningdfoversshto obtain the free
space on the remote archive directories) are very linux-y.The interactive mode uses thecurseslibrary ... poorly.  Keypresses are
not received, screen resizing does not work, and the minimum terminal size
is pretty big.Plotman assumes all plots are k32s.  Again, this is just an unimplemented
generalization.Many features are inconsistently supported between either the "interactive"
mode or the command line mode.There are many bugs and TODOs.Plotman will always look for theplotman.yamlfile within your computer at an OS-based
default location. To generate a defaultplotman.yaml, run:>plotmanconfiggenerateTo display the current location of yourplotman.yamlfile and check if it exists, run:>plotmanconfigpath(See also).InstallationInstallation for Linux:Plotman assumes that a functioningChiainstallation is present on the system. Activate yourchiaenvironment by typingsource /path/to/your/chia/install/activate.Then, install Plotman using the following command:pipinstall--force-reinstallgit+https://github.com/ericaltendorf/plotman@mainWith the new installation we can install this
or with thispython3-mpipinstallplotmanxPlotman will look forplotman.yamlwithin your computer at an OS-based
default location. To create a defaultplotman.yamland display its location,
run the following command:plotmanconfiggenerateThe default configuration file used as a starting point is locatedhereThat's it! You can now run Plotman by typingplotman versionto verify its version.
Runplotman --helpto learn about the available commands.Development note:If you are forking Plotman, simply replace the installation step withpip install --editable .[dev]from the project root directory to installyourversion of plotman with test and development extras.MaintenanceOverviewThis document holds guidance on maintaining aspects of plotman.Using dockerhttps://gist.github.com/snikch/ab15159e633d21619bdf6a056bec8830Thechia plots createCLI parsing codeInsrc/plotman/chia.pythere is code copied from thechia plots createsubcommand's CLI parser definition.
When new versions ofchia-blockchainare released, their interface code should be added to plotman.
plotman commit1b5db4eprovides an example of adding a new version.In many cases, copying code is a poor choice.
It is believed that in this case it is appropriate since the chia code that plotman could import is not necessarily the code that is parsing the plotting process command lines anyways.
The chia command could come from another Python environment, a system package, a.dmg, etc.
This approach also offers future potential of using the proper version of parsing for the specific plot process being inspected.
Finally, this alleviates dealing with the dependency on thechia-blockchainpackage.
In generally, using dependencies is good.
This seems to be an exceptional case.