So only symbolic links are needed

  This feature became useless as fluentd isn't a priority anymore

   The machine should perform only self tests, expose logs and do general healthy checks (Check if something is running, if ntp is running and date is consistent...)

Otherwise it will be installed without our special part, using system
curl.

/reviewed-on nexedi/slapos!639

/reviewed-on !635

also drop test_nextcloud_promises as promises are now checked by
framework.

/reviewed-on nexedi/slapos!636

Prove that:

 * VNC is accessible
 * monitor-base-url on each partition is accessible with password extracted
   from the main partition

frontend-instance-guid and frontend-additional-instance-guid are used to
control where the websocket frontend shall end up.

Real frontend is always requested.

Additional frontend is requested only if frontend-additional-instance-guid is
not empty. This frontend is published as url-additional and can be used for
access to users from some restricted networks.

publish-early does not work in this case, and monitor password is stored
in buildout elsewhere anyway.

Update almost all tests to use nexedi/slapos.core!64 

Notable changes:
 * the testcase class is generated dynamically with `makeModuleSetUpAndTestCaseClass`
 * `self.slap` allow low level control of slapos
 * IP addresses are available as `_ipv6_address` and `_ipv4_address` class attributes
 * `getSupervisorRPCServer` no longer exist, instead use `self.slap.instance_supervisor_rpc` (as context manager)
 * now the framework takes care of running promises and instance step fail when instanciation fail or when promises are not satisfied (as a result, some tests checking promises are dropped)
 * test needs `slapos` and `supervisord` commands in PATH. It's important to have a recent enough `slapos` and not the `~/bin/slapos` from slaprunner which sets `$SLAPOS_CONFIGURATION` 

Following tests were not updated:
 * `caddy-frontend` as this will require more work, because this software uses shared partitions and maybe other things will need to be adapted in the tests. 
 * `slapos-master` as it is same as ERP5 and I thought maybe we can do better than duplicating code, so I left it as is for now.
 * `nextcloud` as this fail the `slapos node instance` step.

There are also a few style changes or small fixes to make pylint happy and some other fixes for problems with softwares and also a fix for seleniumrunner flaky test.

/reviewed-on nexedi/slapos!624

also drop test_turnserver_promises as promises are now checked by
framework.

slapos.cookbook:zero-knowledge.read has this limitation that because it
reads the secret file on __init__, ie. before any other parts are
installed, the value cannot be read the first time.
On first slapos node instance run, the generated turnserver-config has
an empty secret, it's only after the second execution that the secret is
generated. What happens is:
 - first run:
   - read-secret __init__ cannot find the file and does not override
     secret
   - turnserver-config uses the default ${read-secret:secret} (empty
     string)
   - gen-secret install creates the secret file
 - second run
   - read-secret __init__ finds the file and override secret with the
     value read from the file.
   - turnserver-config uses the overriden ${read-secret:secret} (good
     secret)

This was not a problem before, because some frontend promise were
always failing, so we processed this partition several time, but now it
is succesfully processed the first time.

To workadound this, we prevent turnserver from starting if secret is
empty, then promise will fail, instance will be processed a second time
and then turnserver will run with a secret.

This was causing "No JSON object could be decoded"

now that promises are satisfied, we don't retry slapos node instance
again and again, so this test starts earlier and we need to wait longer
for ERP5 to be ready.

Also tolerate that this 503 can be 404 (I think this happened a few time
on test nodes in the past)

This test was just checking the data from the first recv call, but the
data might arrive in multiple times. Call recv in a loop until we
received the end of the expected message (or until timeout when
something goes wrong).