Standalone SlapOS and Slapos instance TestCase

This is about replacing the `utils.py` we have duplicated in each software release tests by a more "official API".

This introduce a  "sandalone slapos API" which are helpers around slapos API to create a recursive SlapOS. This can eventually replace implementation of erp5testnode and slaprunner (but there are no plans for that)

/reviewed-on nexedi/slapos.core!64

slapos/proxy/views.py

@@ -44,6 +44,7 @@ from slapos.util import loads, dumps
 
 import six
 from six.moves import range
+from six.moves.urllib.parse import urlparse
 
 app = Flask(__name__)
 
@@ -316,11 +317,14 @@ def loadComputerConfigurationFromXML():
   computer_dict = loads(xml.encode('utf-8'))
   execute_db('computer', 'INSERT OR REPLACE INTO %s values(:reference, :address, :netmask)',
              computer_dict)
+
+  # remove references to old partitions.
+  execute_db('partition', 'DELETE FROM %s WHERE computer_reference = :reference', computer_dict)
+  execute_db('partition_network', 'DELETE FROM %s WHERE computer_reference = :reference', computer_dict)
+
   for partition in computer_dict['partition_list']:
     partition['computer_reference'] = computer_dict['reference']
     execute_db('partition', 'INSERT OR IGNORE INTO %s (reference, computer_reference) values(:reference, :computer_reference)', partition)
-    execute_db('partition_network', 'DELETE FROM %s WHERE partition_reference = ? AND computer_reference = ?',
-               [partition['reference'], partition['computer_reference']])
     for address in partition['address_list']:
       address['reference'] = partition['tap']['name']
       address['partition_reference'] = partition['reference']
@@ -358,12 +362,61 @@ def supplySupply():
 @app.route('/requestComputerPartition', methods=['POST'])
 def requestComputerPartition():
   parsed_request_dict = parseRequestComputerPartitionForm(request.form)
-
   # Is it a slave instance?
   slave = loads(request.form.get('shared_xml', EMPTY_DICT_XML).encode('utf-8'))
 
   # Check first if instance is already allocated
   if slave:
+    # slapproxy cannot request frontends, but we can workaround common cases,
+    # so that during tests promises are succesful.
+    if not isRequestToBeForwardedToExternalMaster(parsed_request_dict):
+      # if client request a "simple" frontend for an URL, we can tell this
+      # client to use the URL directly.
+      apache_frontend_sr_url_list = (
+          'http://git.erp5.org/gitweb/slapos.git/blob_plain/HEAD:/software/apache-frontend/software.cfg',
+      )
+      if parsed_request_dict['software_release'] in apache_frontend_sr_url_list \
+        and parsed_request_dict.get('software_type', '') in ('', 'RootSoftwareInstance', 'default'):
+        url = parsed_request_dict['partition_parameter_kw'].get('url')
+        if url:
+          app.logger.warning("Bypassing frontend for %s => %s", parsed_request_dict, url)
+          partition = ComputerPartition('', 'Fake frontend for {}'.format(url))
+          partition.slap_computer_id = ''
+          partition.slap_computer_partition_id = ''
+          partition._parameter_dict = {}
+          partition._connection_dict = {
+            'secure_access': url,
+            'domain': urlparse(url).netloc,
+          }
+          return dumps(partition)
+      # another similar case is for KVM frontends. This is used in
+      # request-slave-frontend from software/kvm/instance-kvm.cfg.jinja2
+      # requested values by 'return' recipe are: url resource port domainname
+      kvm_frontend_sr_url_list = (
+          'http://git.erp5.org/gitweb/slapos.git/blob_plain/refs/tags/slapos-0.92:/software/kvm/software.cfg',
+      )
+      if parsed_request_dict['software_release'] in kvm_frontend_sr_url_list \
+          and parsed_request_dict.get('software_type') in ('frontend', ):
+        host = parsed_request_dict['partition_parameter_kw'].get('host')
+        port = parsed_request_dict['partition_parameter_kw'].get('port')
+        if host and port:
+          # host is supposed to be ipv6 without brackets.
+          if ':' in host and host[0] != '[':
+            host = '[%s]' % host
+          url = 'https://%s:%s/' % (host, port)
+          app.logger.warning("Bypassing KVM VNC frontend for %s => %s", parsed_request_dict, url)
+          partition = ComputerPartition('', 'Fake KVM VNC frontend for {}'.format(url))
+          partition.slap_computer_id = ''
+          partition.slap_computer_partition_id = ''
+          partition._parameter_dict = {}
+          partition._connection_dict = {
+            'url': url,
+            'domainname': host,
+            'port': port,
+            'path': '/'
+          }
+          return dumps(partition)
+
     # XXX: change schema to include a simple "partition_reference" which
     # is name of the instance. Then, no need to do complex search here.
     slave_reference = parsed_request_dict['partition_id'] + '_' + parsed_request_dict['partition_reference']

slapos/slap/standalone.py

+# -*- coding: utf-8 -*-
+##############################################################################
+#
+# Copyright (c) 2018 Vifib SARL and Contributors. All Rights Reserved.
+#
+# WARNING: This program as such is intended to be used by professional
+# programmers who take the whole responsibility of assessing all potential
+# consequences resulting from its eventual inadequacies and bugs
+# End users who are looking for a ready-to-use solution with commercial
+# guarantees and support are strongly adviced to contract a Free Software
+# Service Company
+#
+# This program is Free Software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 3
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+##############################################################################
+
+import glob
+import os
+import textwrap
+import logging
+import time
+import errno
+import socket
+import shutil
+
+from six.moves import urllib
+from six.moves import http_client
+
+try:
+  import subprocess32 as subprocess
+except ImportError:
+  import subprocess
+
+import xml_marshaller
+import zope.interface
+import psutil
+
+from .interface.slap import IException
+from .interface.slap import ISupply
+from .interface.slap import IRequester
+
+from .slap import slap
+from ..grid.svcbackend import getSupervisorRPC
+
+
+@zope.interface.implementer(IException)
+class SlapOSNodeCommandError(Exception):
+  """Exception raised when running a SlapOS Node command failed.
+  """
+  def __str__(self):
+    return "{} exitstatus: {} output:\n{}".format(
+        self.__class__.__name__,
+        self.args[0]['exitstatus'],
+        self.args[0]['output'],
+    )
+
+
+@zope.interface.implementer(IException)
+class PathTooDeepError(Exception):
+  """Exception raised when path is too deep to create an unix socket.
+  """
+
+
+class ConfigWriter(object):
+  """Base class for an object writing a config file or wrapper script.
+  """
+  def __init__(self, standalone_slapos):
+    self._standalone_slapos = standalone_slapos
+
+  def writeConfig(self, path):
+    NotImplemented
+
+
+class SupervisorConfigWriter(ConfigWriter):
+  """Write supervisor configuration at etc/supervisor.conf
+  """
+  def _getProgramConfig(self, program_name, command, stdout_logfile):
+    """Format a supervisor program block.
+    """
+    return textwrap.dedent(
+        """\
+        [program:{program_name}]
+        command = {command}
+        autostart = false
+        autorestart = false
+        startretries = 0
+        startsecs = 0
+        redirect_stderr = true
+        stdout_logfile = {stdout_logfile}
+        stdout_logfile_maxbytes = 5MB
+        stdout_logfile_backups = 10
+
+    """.format(**locals()))
+
+  def _getSupervisorConfigParts(self):
+    """Iterator on parts of formatted config.
+    """
+    standalone_slapos = self._standalone_slapos
+    yield textwrap.dedent(
+        """
+        [unix_http_server]
+        file = {standalone_slapos._supervisor_socket}
+
+        [supervisorctl]
+        serverurl = unix://{standalone_slapos._supervisor_socket}
+
+        [supervisord]
+        logfile = {standalone_slapos._supervisor_log}
+        pidfile = {standalone_slapos._supervisor_pid}
+        childlogdir = {standalone_slapos._log_directory}
+
+        [rpcinterface:supervisor]
+        supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
+
+        [program:slapos-proxy]
+        command = slapos proxy start --cfg {standalone_slapos._slapos_config} --verbose
+        startretries = 0
+        startsecs = 0
+        redirect_stderr = true
+        """.format(**locals()))
+
+    for program, program_config in standalone_slapos._slapos_commands.items():
+      yield self._getProgramConfig(
+          program,
+          program_config['command'].format(
+              self=standalone_slapos, debug_args=''),
+          stdout_logfile=program_config.get(
+              'stdout_logfile', 'AUTO').format(self=standalone_slapos))
+
+  def writeConfig(self, path):
+    with open(path, 'w') as f:
+      for part in self._getSupervisorConfigParts():
+        f.write(part)
+
+
+class SlapOSConfigWriter(ConfigWriter):
+  """Write slapos configuration at etc/slapos.cfg
+  """
+  def writeConfig(self, path):
+    standalone_slapos = self._standalone_slapos  # type: StandaloneSlapOS
+    read_only_shared_part_list = '\n  '.join( #  pylint: disable=unused-variable; used in format()
+        standalone_slapos._shared_part_list)
+    with open(path, 'w') as f:
+      f.write(
+          textwrap.dedent(
+              """
+              [slapos]
+              software_root = {standalone_slapos._software_root}
+              instance_root = {standalone_slapos._instance_root}
+              shared_part_list =
+                {read_only_shared_part_list}
+                {standalone_slapos._shared_part_root}
+              master_url = {standalone_slapos._master_url}
+              computer_id = {standalone_slapos._computer_id}
+              root_check = False
+              pidfile_software = {standalone_slapos._instance_pid}
+              pidfile_instance = {standalone_slapos._software_pid}
+              pidfile_report =  {standalone_slapos._report_pid}
+
+              [slapproxy]
+              host = {standalone_slapos._server_ip}
+              port = {standalone_slapos._server_port}
+              database_uri = {standalone_slapos._proxy_database}
+              """.format(**locals())))
+
+
+class SlapOSCommandWriter(ConfigWriter):
+  """Write a bin/slapos wrapper.
+  """
+  def writeConfig(self, path):
+    with open(path, 'w') as f:
+      f.write(
+          textwrap.dedent(
+              """\
+              #!/bin/sh
+              SLAPOS_CONFIGURATION={self._standalone_slapos._slapos_config} \\
+              SLAPOS_CLIENT_CONFIGURATION=$SLAPOS_CONFIGURATION \\
+              exec slapos "$@"
+      """.format(**locals())))
+    os.chmod(path, 0o755)
+
+
+@zope.interface.implementer(ISupply, IRequester)
+class StandaloneSlapOS(object):
+  """A SlapOS that can be embedded in other applications, also useful for testing.
+
+  This plays the role of an `IComputer` where users of classes implementing this
+  interface can install software, create partitions and access parameters of the
+  running partitions.
+
+  Extends the existing `IRequester` and `ISupply`, with the special behavior that
+  `IRequester.request` and `ISupply.supply` will only use the embedded computer.
+  """
+  def __init__(
+      self,
+      base_directory,
+      server_ip,
+      server_port,
+      computer_id='local',
+      shared_part_list=(),
+      software_root=None,
+      instance_root=None,
+      shared_part_root=None):
+    """Constructor, creates a standalone slapos in `base_directory`.
+
+    Arguments:
+      * `base_directory`  -- the directory which will contain softwares and instances.
+      * `server_ip`, `server_port` -- the address this SlapOS proxy will listen to.
+      * `computer_id` -- the id of this computer.
+      * `shared_part_list` -- list of extra paths to use as read-only ${buildout:shared-part-list}.
+      * `software_root` -- directory to install software, default to "soft" in `base_directory`
+      * `instance_root` -- directory to create instances, default to "inst" in `base_directory`
+      * `shared_part_root` -- directory to hold shared parts software, default to "shared" in `base_directory`.
+
+    Error cases:
+      * `PathTooDeepError` when `base_directory` is too deep. Because of limitation
+        with the length of paths of UNIX sockets, too deep paths cannot be used.
+        Note that once slapns work is integrated, this should not be an issue anymore.
+    """
+    self._logger = logging.getLogger(__name__)
+
+    # slapos proxy address
+    self._server_ip = server_ip
+    self._server_port = server_port
+    self._master_url = "http://{server_ip}:{server_port}".format(**locals())
+
+    self._base_directory = base_directory
+    self._shared_part_list = list(shared_part_list)
+
+    self._slapos_commands = {
+        'slapos-node-software': {
+            'command':
+                'slapos node software --cfg {self._slapos_config} --all {debug_args}',
+            'debug_args':
+                '--buildout-debug',
+            'stdout_logfile':
+                '{self._log_directory}/slapos-node-software.log',
+        },
+        'slapos-node-instance': {
+            'command':
+                'slapos node instance --cfg {self._slapos_config} --all {debug_args}',
+            'debug_args':
+                '--buildout-debug',
+            'stdout_logfile':
+                '{self._log_directory}/slapos-node-instance.log',
+        },
+        'slapos-node-report': {
+            'command':
+                'slapos node report --cfg {self._slapos_config} {debug_args}',
+            'log_file':
+                '{self._log_directory}/slapos-node-report.log',
+        }
+    }
+    self._computer_id = computer_id
+    self._slap = slap()
+    self._slap.initializeConnection(self._master_url)
+
+    self._initBaseDirectory(software_root, instance_root, shared_part_root)
+
+  def _initBaseDirectory(self, software_root, instance_root, shared_part_root):
+    """Create the directory after checking it's not too deep.
+    """
+    base_directory = self._base_directory
+    # To prevent error: Cannot open an HTTP server: socket.error reported
+    # AF_UNIX path too long This `base_directory` should not be too deep.
+    # Socket path is 108 char max on linux
+    # https://github.com/torvalds/linux/blob/3848ec5/net/unix/af_unix.c#L234-L238
+    # Supervisord socket name contains the pid number, which is why we add
+    # .xxxxxxx in this check.
+    if len(os.path.join(base_directory, 'supervisord.socket.xxxxxxx')) > 108:
+      raise PathTooDeepError(
+          'working directory ( {base_directory} ) is too deep'.format(
+              **locals()))
+
+    def ensureDirectoryExists(d):
+      if not os.path.exists(d):
+        os.mkdir(d)
+
+    self._software_root = software_root if software_root else os.path.join(
+        base_directory, 'soft')
+    self._instance_root = instance_root if instance_root else os.path.join(
+        base_directory, 'inst')
+    self._shared_part_root = shared_part_root if shared_part_root else os.path.join(
+        base_directory, 'shared')
+    for d in (self._software_root, self._instance_root, self._shared_part_root):
+      ensureDirectoryExists(d)
+      os.chmod(d, 0o750)
+
+    etc_directory = os.path.join(base_directory, 'etc')
+    ensureDirectoryExists(etc_directory)
+    self._supervisor_config = os.path.join(etc_directory, 'supervisord.conf')
+    self._slapos_config = os.path.join(etc_directory, 'slapos.cfg')
+
+    var_directory = os.path.join(base_directory, 'var')
+    ensureDirectoryExists(var_directory)
+    self._proxy_database = os.path.join(var_directory, 'proxy.db')
+
+    # for convenience, make a slapos command for this instance
+    bin_directory = os.path.join(base_directory, 'bin')
+    ensureDirectoryExists(bin_directory)
+
+    self._slapos_bin = os.path.join(bin_directory, 'slapos')
+
+    self._log_directory = os.path.join(var_directory, 'log')
+    ensureDirectoryExists(self._log_directory)
+    self._supervisor_log = os.path.join(self._log_directory, 'supervisord.log')
+
+    run_directory = os.path.join(var_directory, 'run')
+    ensureDirectoryExists(run_directory)
+    self._supervisor_pid = os.path.join(run_directory, 'supervisord.pid')
+    self._software_pid = os.path.join(run_directory, 'slapos-node-software.pid')
+    self._instance_pid = os.path.join(run_directory, 'slapos-node-instance.pid')
+    self._report_pid = os.path.join(run_directory, 'slapos-node-report.pid')
+
+    self._supervisor_socket = os.path.join(run_directory, 'supervisord.sock')
+
+    SupervisorConfigWriter(self).writeConfig(self._supervisor_config)
+    SlapOSConfigWriter(self).writeConfig(self._slapos_config)
+    SlapOSCommandWriter(self).writeConfig(self._slapos_bin)
+
+    self.start()
+
+  @property
+  def computer(self):
+    """Access the computer.
+    """
+    return self._slap.registerComputer(self._computer_id)
+
+  @property
+  def software_directory(self):
+    # type: () -> str
+    """Path to software directory
+    """
+    return self._software_root
+
+  @property
+  def shared_directory(self):
+    # type: () -> str
+    """Path to shared parts directory
+    """
+    return self._shared_part_root
+
+  @property
+  def instance_directory(self):
+    # type: () -> str
+    """Path to instance directory
+    """
+    return self._instance_root
+
+  @property
+  def system_supervisor_rpc(self):
+    """A xmlrpc connection to control the "System" supervisor.
+
+    The system supervisor is used internally by StandaloneSlapOS to start
+    slap proxy and run slapos node commands.
+
+    This should be used as a context manager.
+    """
+    return getSupervisorRPC(self._supervisor_socket)
+
+  @property
+  def instance_supervisor_rpc(self):
+    """A xmlrpc connection to control the "Instance" supervisor.
+
+    The instance supervisor is the one started implictly by slapos node instance.
+
+    This should be used as a context manager.
+    """
+    return getSupervisorRPC(
+        # this socket path is not configurable.
+        os.path.join(self._instance_root, "supervisord.socket"))
+
+  def format(
+      self,
+      partition_count,
+      ipv4_address,
+      ipv6_address,
+      partition_base_name="slappart"):
+    """Creates `partition_count` partitions.
+
+    All partitions have the same `ipv4_address` and `ipv6_address` and
+    use the current system user.
+
+    When calling this a second time with a lower `partition_count` or with
+    different `partition_base_name` will delete existing partitions.
+
+    Error cases:
+        * ValueError when re-formatting should delete partitions that are busy.
+    """
+    for path in (
+        self._software_root,
+        self._shared_part_root,
+        self._instance_root,
+    ):
+      if not os.path.exists(path):
+        os.mkdir(path)
+
+    # check for partitions to remove
+    unknown_partition_set = set([])
+    for path in glob.glob(os.path.join(self._instance_root, '*')):
+      # var and etc are some slapos "system" directories, not partitions
+      if os.path.isdir(path) and os.path.basename(path) not in ('var', 'etc'):
+        unknown_partition_set.add(path)
+
+    # create partitions and configure computer
+    partition_list = []
+    for i in range(partition_count):
+      partition_reference = '%s%s' % (partition_base_name, i)
+
+      partition_path = os.path.join(self._instance_root, partition_reference)
+      unknown_partition_set.discard(partition_path)
+      if not (os.path.exists(partition_path)):
+        os.mkdir(partition_path)
+      os.chmod(partition_path, 0o750)
+      partition_list.append({
+          'address_list': [
+              {
+                  'addr': ipv4_address,
+                  'netmask': '255.255.255.255'
+              },
+              {
+                  'addr': ipv6_address,
+                  'netmask': 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'
+              },
+          ],
+          'path': partition_path,
+          'reference': partition_reference,
+          'tap': {
+              'name': partition_reference
+          },
+      })
+
+    if unknown_partition_set:
+      # sanity check that we are not removing partitions in use
+      computer_partition_dict = {
+          computer_part.getId(): computer_part
+          for computer_part in self.computer.getComputerPartitionList()
+      }
+      for part in unknown_partition_set:
+        # used in format(**locals()) below
+        part_id = os.path.basename(part)  # pylint: disable=unused-variable
+        computer_partition = computer_partition_dict.get(os.path.basename(part))
+        if computer_partition is not None \
+             and computer_partition.getState() != "destroyed":
+          raise ValueError(
+              "Cannot reformat to remove busy partition at {part_id}".format(
+                  **locals()))
+
+    self.computer.updateConfiguration(
+        xml_marshaller.xml_marshaller.dumps({
+            'address': ipv4_address,
+            'netmask': '255.255.255.255',
+            'partition_list': partition_list,
+            'reference': self._computer_id,
+            'instance_root': self._instance_root,
+            'software_root': self._software_root
+        }))
+
+    for part in unknown_partition_set:
+      self._logger.debug(
+          "removing partition no longer part of format spec %s", part)
+      shutil.rmtree(part)
+
+  def supply(self, software_url, computer_guid=None, state="available"):
+    """Supply a software, see ISupply.supply
+
+    Software can only be supplied on this embedded computer.
+    """
+    if computer_guid not in (None, self._computer_id):
+      raise ValueError("Can only supply on embedded computer")
+    self._slap.registerSupply().supply(
+        software_url,
+        self._computer_id,
+        state=state,
+    )
+
+  def request(
+      self,
+      software_release,
+      partition_reference,
+      software_type=None,
+      shared=False,
+      partition_parameter_kw=None,
+      filter_kw=None,
+      state=None):
+    """Request an instance, see IRequester.request
+
+    Instance can only be requested on this embedded computer.
+    """
+    if filter_kw is not None:
+      raise ValueError("Can only request on embedded computer")
+    return self._slap.registerOpenOrder().request(
+        software_release,
+        software_type=software_type,
+        partition_reference=partition_reference,
+        shared=shared,
+        partition_parameter_kw=partition_parameter_kw,
+        filter_kw=filter_kw,
+        state=state)
+
+  def start(self):
+    """Start the system.
+
+    If system was stopped, it will start partitions.
+    If system was already running, this does not restart partitions.
+    """
+    self._logger.debug("Starting StandaloneSlapOS in %s", self._base_directory)
+    self._ensureSupervisordStarted()
+    self._ensureSlapOSAvailable()
+
+  def stop(self):
+    """Stops all services.
+
+    This methods blocks until services are stopped or a timeout is reached.
+
+    Error cases:
+      * `Exception` when unexpected error occurs trying to stop supervisors.
+    """
+    self._logger.info("shutting down")
+
+    # shutdown slapos node instance supervisor, if it has been created.
+    instance_process_alive = []
+    if os.path.exists(os.path.join(self._instance_root, 'etc',
+                                   'supervisord.conf')):
+      try:
+        with self.instance_supervisor_rpc as instance_supervisor:
+          instance_supervisor_process = psutil.Process(
+              instance_supervisor.getPID())
+          instance_supervisor.stopAllProcesses()
+          instance_supervisor.shutdown()
+          # shutdown returns before process is completly stopped,
+          # so wait for process.
+          _, instance_process_alive = psutil.wait_procs(
+              [instance_supervisor_process], timeout=10)
+      except BaseException as e:
+        self._logger.info("Ignoring exception while stopping instances: %s", e)
+
+    with self.system_supervisor_rpc as system_supervisor:
+      system_supervisor_process = psutil.Process(system_supervisor.getPID())
+      system_supervisor.stopAllProcesses()
+      system_supervisor.shutdown()
+    _, alive = psutil.wait_procs([system_supervisor_process], timeout=10)
+    if alive + instance_process_alive:
+      raise RuntimeError(
+          "Could not terminate some processes: {}".format(
+              alive + instance_process_alive))
+
+  def waitForSoftware(self, max_retry=0, debug=False, error_lines=30):
+    """Synchronously install or uninstall all softwares previously supplied/removed.
+
+    This method retries on errors. If after `max_retry` times there's
+    still an error, the error is raised, containing `error_lines` of output
+    from the buildout command.
+
+    If `debug` is true, buildout is executed in the foreground, with flags to
+    drop in a debugger session if error occurs.
+
+    Error cases:
+      * `SlapOSNodeCommandError` when buildout error while installing software.
+      * Unexpected `Exception` if unable to connect to embedded slap server.
+    """
+    return self._runSlapOSCommand(
+        'slapos-node-software',
+        max_retry=max_retry,
+        debug=debug,
+        error_lines=error_lines,
+    )
+
+  def waitForInstance(self, max_retry=0, debug=False, error_lines=500):
+    """Instantiate all partitions previously requested for start.
+
+    This method retries on errors. If after `max_retry` times there's
+    still an error, the error is raised, containing `error_lines` of output
+    from the buildout command.
+
+    With instance with multiple partition, the failing partition is not
+    always the last processed one, so by default we include more lines of
+    output.
+
+    If `debug` is true, buildout is executed in the foreground, with flags to
+    drop in a debugger session if error occurs.
+
+    Error cases:
+      * `SlapOSNodeCommandError` when buildout error while creating instances.
+      * Unexpected `Exception` if unable to connect to embedded slap server.
+    """
+    return self._runSlapOSCommand(
+        'slapos-node-instance',
+        max_retry=max_retry,
+        debug=debug,
+        error_lines=error_lines,
+    )
+
+  def waitForReport(self, max_retry=0, debug=False, error_lines=30):
+    """Destroy all partitions previously requested for destruction.
+
+    This method retries on errors. If after `max_retry` times there's
+    still an error, the error is raised, containing `error_lines` of output
+    from the buildout command.
+
+    If `debug` is true, buildout is executed in the foreground, with flags to
+    drop in a debugger session if error occurs.
+
+    Error cases:
+      * `SlapOSNodeCommandError` when buildout error while destroying instances.
+      * Unexpected `Exception` if unable to connect to embedded slap server.
+    """
+    return self._runSlapOSCommand(
+        'slapos-node-report',
+        max_retry=max_retry,
+        debug=debug,
+        error_lines=error_lines,
+    )
+
+  def _runSlapOSCommand(
+      self, command, max_retry=0, debug=False, error_lines=30):
+    if debug:
+      prog = self._slapos_commands[command]
+      # used in format(**locals()) below
+      debug_args = prog.get('debug_args', '')  # pylint: disable=unused-variable
+      return subprocess.check_call(
+          prog['command'].format(**locals()), shell=True)
+
+    with self.system_supervisor_rpc as supervisor:
+      retry = 0
+      while True:
+        self._logger.info("starting command %s (retry:%s)", command, retry)
+        supervisor.startProcess(command, False)
+
+        delay = 0.1
+        while True:
+          self._logger.debug("retry %s: sleeping %s", retry, delay)
+          # we start waiting a short delay and increase the delay each loop,
+          # because when software is already built, this should return fast,
+          # but when we build a full software we don't need to poll the
+          # supervisor too often.
+          time.sleep(delay)
+          delay = min(delay * 1.2, 300)
+          process_info = supervisor.getProcessInfo(command)
+          if process_info['statename'] in ('EXITED', 'FATAL'):
+            self._logger.debug("SlapOS command finished %s" % process_info)
+            if process_info['exitstatus'] == 0:
+              return
+            if retry >= max_retry:
+              # get the last lines of output, at most `error_lines`. If
+              # these lines are long, the output may be truncated.
+              _, log_offset, _ = supervisor.tailProcessStdoutLog(command, 0, 0)
+              output, _, _ = supervisor.tailProcessStdoutLog(
+                  command, log_offset - (2 << 13), 2 << 13)
+              raise SlapOSNodeCommandError({
+                  'output': '\n'.join(output.splitlines()[-error_lines:]),
+                  'exitstatus': process_info['exitstatus'],
+              })
+            break
+        retry += 1
+
+  def _ensureSupervisordStarted(self):
+    if os.path.exists(self._supervisor_pid):
+      with open(self._supervisor_pid, 'r') as f:
+        try:
+          pid = int(f.read())
+        except (ValueError, TypeError):
+          self._logger.debug(
+              "Error reading supervisor pid from file, assuming it's not running"
+          )
+        else:
+          try:
+            process = psutil.Process(pid)
+          except psutil.NoSuchProcess:
+            pass
+          else:
+            if process.name() == 'supervisord':
+              # OK looks already running
+              self._logger.debug("Supervisor running with pid %s", pid)
+              return
+          self._logger.debug("Supervisor pid file seem stale")
+    # start new supervisord
+    output = subprocess.check_output(
+        ['supervisord'],
+        cwd=self._base_directory,
+    )
+    self._logger.debug("Started new supervisor: %s", output)
+
+  def _isSlapOSAvailable(self):
+    try:
+      urllib.request.urlopen(self._master_url).close()
+    except urllib.error.HTTPError as e:
+      # root URL (/) of slapproxy is 404
+      if e.code == http_client.NOT_FOUND:
+        return True
+      raise
+    except urllib.error.URLError as e:
+      if e.reason.errno == errno.ECONNREFUSED:
+        return False
+      raise
+    except socket.error as e:
+      if e.errno == errno.ECONNRESET:
+        return False
+      raise
+    except http_client.HTTPException:
+      return False
+    return True  # (if / becomes 200 OK)
+
+  def _ensureSlapOSAvailable(self):
+    # Wait for proxy to accept connections
+    for i in range(2**8):
+      if self._isSlapOSAvailable():
+        return
+      time.sleep(i * .01)
+    raise RuntimeError("SlapOS not started")

slapos/testing/__init__.py

+# -*- coding: utf-8 -*-
+##############################################################################
+#
+# Copyright (c) 2018 Vifib SARL and Contributors. All Rights Reserved.
+#
+# WARNING: This program as such is intended to be used by professional
+# programmers who take the whole responsibility of assessing all potential
+# consequences resulting from its eventual inadequacies and bugs
+# End users who are looking for a ready-to-use solution with commercial
+# guarantees and support are strongly adviced to contract a Free Software
+# Service Company
+#
+# This program is Free Software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 3
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+##############################################################################

slapos/testing/testcase.py

+# -*- coding: utf-8 -*-
+##############################################################################
+#
+# Copyright (c) 2018 Vifib SARL and Contributors. All Rights Reserved.
+#
+# WARNING: This program as such is intended to be used by professional
+# programmers who take the whole responsibility of assessing all potential
+# consequences resulting from its eventual inadequacies and bugs
+# End users who are looking for a ready-to-use solution with commercial
+# guarantees and support are strongly adviced to contract a Free Software
+# Service Company
+#
+# This program is Free Software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 3
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+##############################################################################
+
+import unittest
+import os
+import glob
+import logging
+
+try:
+  import subprocess32 as subprocess
+except ImportError:
+  import subprocess
+  subprocess  # pyflakes
+
+from .utils import getPortFromPath
+
+from ..slap.standalone import StandaloneSlapOS
+from ..slap.standalone import SlapOSNodeCommandError
+from ..slap.standalone import PathTooDeepError
+from ..grid.utils import md5digest
+
+try:
+  from typing import Iterable, Tuple, Callable, Type
+except ImportError:
+  pass
+
+
+def makeModuleSetUpAndTestCaseClass(
+    software_url,
+    base_directory=None,
+    ipv4_address=os.environ['SLAPOS_TEST_IPV4'],
+    ipv6_address=os.environ['SLAPOS_TEST_IPV6'],
+    debug=bool(int(os.environ.get('SLAPOS_TEST_DEBUG', 0))),
+    verbose=bool(int(os.environ.get('SLAPOS_TEST_VERBOSE', 0))),
+    shared_part_list=os.environ.get('SLAPOS_TEST_SHARED_PART_LIST',
+                                    '').split(os.pathsep),
+):
+  # type: (str, str, str, str, bool, bool, List[str]) -> Tuple[Callable[[], None], Type[SlapOSInstanceTestCase]]
+  """Create a setup module function and a testcase for testing `software_url`.
+
+  This function returns a tuple of two arguments:
+   * a function to install the software, to be used as `unittest`'s
+     `setUpModule`
+   * a base class for test cases.
+
+  The SlapOS instance will be using ip addresses defined by
+  environment variables `SLAPOS_TEST_IPV4` and `SLAPOS_TEST_IPV6`, or by the
+  explicits `ipv4_address` and `ipv6_address` arguments.
+
+  To ease development and troubleshooting, two switches are available:
+   * `verbose` (also controlled by `SLAPOS_TEST_VERBOSE` environment variable)
+     to tell the test framework to log information describing the actions taken.
+   * `debug` (also controlled by `SLAPOS_TEST_DEBUG` environment variable) to
+     enable debugging mode which will drop in a debugger session when errors
+     occurs.
+
+  The base_directory directory is by default .slapos in current directory,
+  or a path from `SLAPOS_TEST_WORKING_DIR` environment variable.
+
+  This test class will use its own directory for shared parts and can also
+  paths from `shared_part_list` argument to lookup existing parts.
+  This is controlled by SLAPOS_TEST_SHARED_PART_LIST environment variable,
+  which should be a : separated list of path.
+
+  A note about paths:
+    SlapOS itself and some services running in SlapOS uses unix sockets and
+    (sometimes very) deep paths, which does not play very well together.
+    To workaround this, users can set `SLAPOS_TEST_WORKING_DIR` environment
+    variable to the path of a short enough directory and local slapos will
+    use this directory.
+    The partitions references will be named after the unittest class name,
+    which can also lead to long paths. For this, unit test classes can define
+    a `__partition_reference__` attribute which will be used as partition
+    reference. If the class names are long, the trick is then to use a shorter
+    `__partition_reference__`.
+    See https://lab.nexedi.com/kirr/slapns for a solution to this problem.
+  """
+  if base_directory is None:
+    base_directory = os.path.realpath(
+        os.environ.get(
+            'SLAPOS_TEST_WORKING_DIR', os.path.join(os.getcwd(), '.slapos')))
+  # TODO: fail if already running ?
+  try:
+    slap = StandaloneSlapOS(
+        base_directory=base_directory,
+        server_ip=ipv4_address,
+        server_port=getPortFromPath(base_directory),
+        shared_part_list=shared_part_list)
+  except PathTooDeepError:
+    raise RuntimeError(
+        'base directory ( {} ) is too deep, try setting '
+        'SLAPOS_TEST_WORKING_DIR to a shallow enough directory'.format(
+            base_directory))
+
+  cls = type(
+      'SlapOSInstanceTestCase for {}'.format(software_url),
+      (SlapOSInstanceTestCase,), {
+          'slap': slap,
+          'getSoftwareURL': classmethod(lambda _cls: software_url),
+          '_debug': debug,
+          '_verbose': verbose,
+          '_ipv4_address': ipv4_address,
+          '_ipv6_address': ipv6_address
+      })
+
+  class SlapOSInstanceTestCase_(cls, SlapOSInstanceTestCase):
+    # useless intermediate class so that editors provide completion anyway.
+    pass
+
+  def setUpModule():
+    # type: () -> None
+    if debug:
+      unittest.installHandler()
+    if verbose or debug:
+      logging.basicConfig(level=logging.DEBUG)
+    installSoftwareUrlList(cls, [software_url], debug=debug)
+
+  return setUpModule, SlapOSInstanceTestCase_
+
+
+def checkSoftware(slap, software_url):
+  # type: (StandaloneSlapOS, str) -> None
+  """Check software installation.
+
+  This perform a few basic static checks for common problems
+  with software installations.
+  """
+  software_hash = md5digest(software_url)
+
+  error_list = []
+  # Check that all components set rpath correctly and we don't have miss linking any libraries.
+  for path in (os.path.join(slap.software_directory,
+                            software_hash), slap.shared_directory):
+    if not glob.glob(os.path.join(path, '*')):
+      # shared might be empty (when using a slapos command that does not support shared yet).
+      continue
+    out = ''
+    try:
+      out = subprocess.check_output(
+          "find . -type f -executable "
+
+          # We ignore parts that are binary distributions.
+          "| egrep -v /parts/java-re.*/ "
+          "| egrep -v /parts/firefox-.*/ "
+          "| egrep -v /parts/chromium-.*/ "
+          "| egrep -v /parts/chromedriver-.*/ "
+
+          # nss has no valid rpath. It does not seem to be a problem in our case.
+          "| egrep -v /parts/nss/ "
+          "| xargs ldd "
+          r"| egrep '(^\S|not found)' "
+          "| grep -B1 'not found'",
+          shell=True,
+          stderr=subprocess.STDOUT,
+          cwd=path,
+      )
+    except subprocess.CalledProcessError as e:
+      # The "good case" is when grep does not match anything, but in
+      # that case, it exists with exit code 1, so we accept this case.
+      if e.returncode != 1 or e.output:
+        error_list.append(e.output)
+    if out:
+      error_list.append(out)
+
+  # check this software is not referenced in any shared parts.
+  for signature_file in glob.glob(os.path.join(slap.shared_directory, '*', '*',
+                                               '.*slapos.*.signature')):
+    with open(signature_file) as f:
+      signature_content = f.read()
+      if software_hash in signature_content:
+        error_list.append(
+            "Software hash present in signature {}\n{}\n".format(
+                signature_file, signature_content))
+
+  if error_list:
+    raise RuntimeError('\n'.join(error_list))
+
+
+def installSoftwareUrlList(cls, software_url_list, max_retry=2, debug=False):
+  # type: (Type[SlapOSInstanceTestCase], Iterable[str], int, bool) -> None
+  """Install softwares on the current testing slapos, for use in `setUpModule`.
+
+  This also check softwares with `checkSoftware`
+  """
+  try:
+    for software_url in software_url_list:
+      cls.logger.debug("Supplying %s", software_url)
+      cls.slap.supply(software_url)
+    cls.logger.debug("Waiting for slapos node software to build")
+    cls.slap.waitForSoftware(max_retry=max_retry, debug=debug)
+    for software_url in software_url_list:
+      checkSoftware(cls.slap, software_url)
+  except BaseException as e:
+    if not debug:
+      cls.logger.exception("Error building software, removing")
+      try:
+        for software_url in software_url_list:
+          cls.logger.debug("Removing %s", software_url)
+          cls.slap.supply(software_url, state="destroyed")
+        cls.logger.debug("Waiting for slapos node software to remove")
+        cls.slap.waitForSoftware(max_retry=max_retry, debug=debug)
+      except BaseException:
+        cls.logger.exception("Error removing software")
+        pass
+    cls._cleanup()
+    raise e
+
+
+class SlapOSInstanceTestCase(unittest.TestCase):
+  """Install one slapos instance.
+
+  This test case install software(s) and request one instance
+  during `setUpClass` and destroy that instance during `tearDownClass`.
+
+  Software Release URL, Instance Software Type and Instance Parameters
+  can be defined on the class.
+
+  All tests from the test class will run with the same instance.
+
+  The following class attributes are available:
+
+    * `computer_partition`:  the `slapos.slap.slap.ComputerPartition`
+      computer partition instance.
+
+    * `computer_partition_root_path`: the path of the instance root
+      directory.
+
+  This class is not supposed to be imported directly, but needs to be setup by
+  calling makeModuleSetUpAndTestCaseClass.
+  """
+  # can set this to true to enable debugging utilities
+  _debug = False
+  # can set this to true to enable more verbose output
+  _verbose = False
+  # maximum retries for `slapos node instance`
+  instance_max_retry = 10
+  # maximum retries for `slapos node report`
+  report_max_retry = 0
+  # number of partitions needed for this instance
+  partition_count = 10
+  # reference of the default requested partition
+  default_partition_reference = 'testing partition 0'
+
+  # a logger for messages of the testing framework
+  logger = logging.getLogger(__name__)
+
+  # Dynamic members
+  slap = None  # type: StandaloneSlapOS
+  _ipv4_address = ""
+  _ipv6_address = ""
+
+  # Methods to be defined by subclasses.
+  @classmethod
+  def getSoftwareURL(cls):
+    """Return URL of software release to request instance.
+
+    This method will be defined when initialising the class
+    with makeModuleSetUpAndTestCaseClass.
+    """
+    raise NotImplementedError()
+
+  @classmethod
+  def getInstanceParameterDict(cls):
+    """Return instance parameters.
+
+    To be defined by subclasses if they need to request instance
+    with specific parameters.
+    """
+    return {}
+
+  @classmethod
+  def getInstanceSoftwareType(cls):
+    """Return software type for instance, default "".
+
+    To be defined by subclasses if they need to request instance with specific
+    software type.
+    """
+    return ""
+
+  # Unittest methods
+  @classmethod
+  def setUpClass(cls):
+    """Request an instance.
+    """
+    cls._instance_parameter_dict = cls.getInstanceParameterDict()
+
+    try:
+      cls.logger.debug("Starting")
+      cls.slap.start()
+      cls.logger.debug(
+          "Formatting to remove old partitions XXX should not be needed because we delete ..."
+      )
+      cls.slap.format(0, cls._ipv4_address, cls._ipv6_address)
+      cls.logger.debug("Formatting with %s partitions", cls.partition_count)
+      cls.slap.format(
+          cls.partition_count, cls._ipv4_address, cls._ipv6_address,
+          getattr(cls, '__partition_reference__', '{}-'.format(cls.__name__)))
+
+      # request
+      cls.requestDefaultInstance()
+
+      # slapos node instance
+      cls.logger.debug("Waiting for instance")
+      # waitForInstance does not tolerate any error but with instances,
+      # promises sometimes fail on first run, because services did not
+      # have time to start.
+      # To make debug usable, we tolerate instance_max_retry-1 errors and
+      # only debug the last.
+      if cls._debug and cls.instance_max_retry:
+        try:
+          cls.slap.waitForInstance(max_retry=cls.instance_max_retry - 1)
+        except SlapOSNodeCommandError:
+          cls.slap.waitForInstance(debug=True)
+      else:
+        cls.slap.waitForInstance(
+            max_retry=cls.instance_max_retry, debug=cls._debug)
+
+      # expose some class attributes so that tests can use them:
+      # the main ComputerPartition instance, to use getInstanceParameterDict
+      cls.computer_partition = cls.requestDefaultInstance()
+
+      # the path of the instance on the filesystem, for low level inspection
+      cls.computer_partition_root_path = os.path.join(
+          cls.slap._instance_root, cls.computer_partition.getId())
+      cls.logger.debug("setUpClass done")
+
+    except BaseException:
+      cls.logger.exception("Error during setUpClass")
+      cls._cleanup()
+      cls.setUp = lambda self: self.fail('Setup Class failed.')
+      raise
+
+  @classmethod
+  def tearDownClass(cls):
+    """Tear down class, stop the processes and destroy instance.
+    """
+    cls._cleanup()
+
+  # implementation methods
+  @classmethod
+  def _cleanup(cls):
+    """Destroy all instances and stop subsystem.
+    Catches and log all exceptions.
+    """
+    try:
+      cls.requestDefaultInstance(state='destroyed')
+    except:
+      cls.logger.exception("Error during request destruction")
+    try:
+      cls.slap.waitForReport(max_retry=cls.report_max_retry, debug=cls._debug)
+    except:
+      cls.logger.exception("Error during actual destruction")
+    leaked_partitions = [
+        cp for cp in cls.slap.computer.getComputerPartitionList()
+        if cp.getState() != 'destroyed'
+    ]
+    if leaked_partitions:
+      cls.logger.critical(
+          "The following partitions were not cleaned up: %s",
+          [cp.getId() for cp in leaked_partitions])
+    for cp in leaked_partitions:
+      try:
+        cls.slap.request(
+            software_release=cp.getSoftwareRelease().getURI(),
+            # software_type=cp.getType(), # TODO
+            # XXX is this really the reference ?
+            partition_reference=cp.getInstanceParameterDict()['instance_title'],
+            state="destroyed")
+      except:
+        cls.logger.exception(
+            "Error during request destruction of leaked partition")
+    try:
+      cls.slap.waitForReport(max_retry=cls.report_max_retry, debug=cls._debug)
+    except:
+      cls.logger.exception("Error during leaked partitions actual destruction")
+    try:
+      cls.slap.stop()
+    except:
+      cls.logger.exception("Error during stop")
+
+  @classmethod
+  def requestDefaultInstance(cls, state='started'):
+    software_url = cls.getSoftwareURL()
+    software_type = cls.getInstanceSoftwareType()
+    cls.logger.debug(
+        'requesting "%s" software:%s type:%s state:%s parameters:%s',
+        cls.default_partition_reference, software_url, software_type, state,
+        cls._instance_parameter_dict)
+    return cls.slap.request(
+        software_release=software_url,
+        software_type=software_type,
+        partition_reference=cls.default_partition_reference,
+        partition_parameter_kw=cls._instance_parameter_dict,
+        state=state)

slapos/testing/utils.py

+# -*- coding: utf-8 -*-
+##############################################################################
+#
+# Copyright (c) 2018 Vifib SARL and Contributors. All Rights Reserved.
+#
+# WARNING: This program as such is intended to be used by professional
+# programmers who take the whole responsibility of assessing all potential
+# consequences resulting from its eventual inadequacies and bugs
+# End users who are looking for a ready-to-use solution with commercial
+# guarantees and support are strongly adviced to contract a Free Software
+# Service Company
+#
+# This program is Free Software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 3
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+##############################################################################
+
+import socket
+import hashlib
+from contextlib import closing
+
+
+# Utility functions
+def findFreeTCPPort(ip=''):
+  # type: (str) -> int
+  """Find a free TCP port to listen to.
+  """
+  s = socket.socket(
+      socket.AF_INET6 if ':' in ip else socket.AF_INET, socket.SOCK_STREAM)
+  with closing(s):
+    s.bind((ip, 0))
+    return s.getsockname()[1]
+
+
+def getPortFromPath(path):
+  # type: (str) -> int
+  """A stable port using a hash from path.
+  """
+  return 1024 + int(
+      hashlib.md5(path.encode('utf-8', 'backslashreplace')).hexdigest(),
+      16) % (65535 - 1024)

slapos/tests/test_slapproxy.py

@@ -129,8 +129,8 @@ database_uri = %(tempdir)s/lib/proxy.db
       computer_id = self.computer_id
     computer_dict = {
         'reference': computer_id,
-        'address': '123.456.789',
-        'netmask': 'fffffffff',
+        'address': '12.34.56.78',
+        'netmask': '255.255.255.255',
         'partition_list': [],
     }
     for i in range(partition_amount):
@@ -160,6 +160,47 @@ database_uri = %(tempdir)s/lib/proxy.db
     views.is_schema_already_executed = False
 
 
+class TestLoadComputerConfiguration(BasicMixin, unittest.TestCase):
+  """tests /loadComputerConfigurationFromXML the endpoint for format
+  """
+  def test_loadComputerConfigurationFromXML_remove_partitions(self):
+    computer_dict = {
+        'reference': self.computer_id,
+        'address': '12.34.56.78',
+        'netmask': '255.255.255.255',
+        'partition_list': [
+            {
+                'reference': 'slappart1',
+                'address_list': [
+                    {
+                        'addr': '1.2.3.4',
+                        'netmask': '255.255.255.255'
+                    },
+                ],
+                'tap': {'name': 'tap0'},
+            }
+        ],
+    }
+    rv = self.app.post('/loadComputerConfigurationFromXML', data={
+        'computer_id': self.computer_id,
+        'xml': dumps(computer_dict),
+    })
+    self.assertEqual(rv._status_code, 200)
+    # call again with different partition reference, old partition will be removed
+    # and a new partition will be used.
+    computer_dict['partition_list'][0]['reference'] = 'something else'
+    rv = self.app.post('/loadComputerConfigurationFromXML', data={
+        'computer_id': self.computer_id,
+        'xml': dumps(computer_dict),
+    })
+    self.assertEqual(rv._status_code, 200)
+    computer = loads(
+        self.app.get('/getFullComputerInformation', query_string={'computer_id': self.computer_id}).data)
+    self.assertEqual(
+        ['something else'],
+        [p.getId() for p in computer._computer_partition_list])
+
+
 class TestInformation(BasicMixin, unittest.TestCase):
   """
   Test Basic response of slapproxy
@@ -682,6 +723,44 @@ class TestRequest(MasterMixin):
     partition_new = self.request('http://sr//', None, 'myinstance', 'slappart0')
     self.assertEqual(partition_new.getConnectionParameter('foo'), '1')
 
+  def test_request_frontend(self):
+    # slapproxy tells client to bypass "simple" frontends by just using the URL.
+    request = self.request(
+        'http://git.erp5.org/gitweb/slapos.git/blob_plain/HEAD:/software/apache-frontend/software.cfg',
+        None,
+        self.id(),
+        'slappart0',
+        shared=True,
+        partition_parameter_kw={'url': 'https://[::1]:123/', })
+    self.assertEqual(
+        'https://[::1]:123/',
+        request.getConnectionParameterDict()['secure_access'])
+    self.assertEqual(
+        '[::1]:123',
+        request.getConnectionParameterDict()['domain'])
+
+  def test_request_kvm_frontend(self):
+    # slapproxy tells client to bypass kvm vnc frontends by building an URL using the backend.
+    request = self.request(
+        'http://git.erp5.org/gitweb/slapos.git/blob_plain/refs/tags/slapos-0.92:/software/kvm/software.cfg',
+        'frontend',
+        self.id(),
+        'slappart0',
+        shared=True,
+        partition_parameter_kw={'host': '::1', 'port': '123'})
+    self.assertEqual(
+        'https://[::1]:123/',
+        request.getConnectionParameterDict()['url'])
+    self.assertEqual(
+        '[::1]',
+        request.getConnectionParameterDict()['domainname'])
+    self.assertEqual(
+        '123',
+        request.getConnectionParameterDict()['port'])
+    self.assertEqual(
+        '/',
+        request.getConnectionParameterDict()['path'])
+
 
 class TestSlaveRequest(MasterMixin):
   """
@@ -1221,8 +1300,8 @@ database_uri = %(tempdir)s/lib/external_proxy.db
       computer_id = self.external_computer_id
     computer_dict = {
         'reference': computer_id,
-        'address': '123.456.789',
-        'netmask': 'fffffffff',
+        'address': '12.34.56.78',
+        'netmask': '255.255.255.255',
         'partition_list': [],
     }
     for i in range(partition_amount):

slapos/tests/test_standalone.py

+##############################################################################
+#
+# Copyright (c) 2018 Vifib SARL and Contributors. All Rights Reserved.
+#
+# WARNING: This program as such is intended to be used by professional
+# programmers who take the whole responsibility of assessing all potential
+# consequences resulting from its eventual inadequacies and bugs
+# End users who are looking for a ready-to-use solution with commercial
+# guarantees and support are strongly adviced to contract a Free Software
+# Service Company
+#
+# This program is Free Software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 3
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+##############################################################################
+
+import unittest
+import mock
+import os
+import tempfile
+import textwrap
+import shutil
+import hashlib
+import socket
+import errno
+import time
+import multiprocessing
+from contextlib import closing
+
+import psutil
+
+from slapos.slap.standalone import StandaloneSlapOS
+from slapos.slap.standalone import SlapOSNodeCommandError
+
+SLAPOS_TEST_IPV4 = os.environ['SLAPOS_TEST_IPV4']
+SLAPOS_TEST_IPV6 = os.environ['SLAPOS_TEST_IPV6']
+SLAPOS_TEST_PORT = int(os.environ.get('SLAPOS_TEST_PORT', 33333))
+
+
+def checkPortIsFree():
+  """Sanity check that we did not leak a process listening on this port.
+  """
+  s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+  with closing(s):
+    try:
+      s.connect((SLAPOS_TEST_IPV4, SLAPOS_TEST_PORT))
+      raise RuntimeError(
+          "Port needed for tests ({SLAPOS_TEST_IPV4}:{SLAPOS_TEST_PORT}) is already in use"
+          .format(**globals()))
+    except socket.error as e:
+      if e.errno == errno.ECONNREFUSED:
+        return
+      raise
+
+
+class TestSlapOSStandaloneSetup(unittest.TestCase):
+  # BBB python2
+  assertRaisesRegex = getattr(
+      unittest.TestCase, 'assertRaisesRegex',
+      unittest.TestCase.assertRaisesRegexp)
+
+  def setUp(self):
+    checkPortIsFree()
+
+  def test_format(self):
+    working_dir = tempfile.mkdtemp(prefix=__name__)
+    self.addCleanup(shutil.rmtree, working_dir)
+    standalone = StandaloneSlapOS(
+        working_dir, SLAPOS_TEST_IPV4, SLAPOS_TEST_PORT)
+    self.addCleanup(standalone.stop)
+    standalone.format(3, SLAPOS_TEST_IPV4, SLAPOS_TEST_IPV6)
+
+    self.assertTrue(os.path.exists(standalone.software_directory))
+    self.assertTrue(os.path.exists(standalone.instance_directory))
+    self.assertTrue(
+        os.path.exists(
+            os.path.join(standalone.instance_directory, 'slappart0')))
+    self.assertTrue(
+        os.path.exists(
+            os.path.join(standalone.instance_directory, 'slappart1')))
+    self.assertTrue(
+        os.path.exists(
+            os.path.join(standalone.instance_directory, 'slappart2')))
+
+  def test_reformat_less_partitions(self):
+    working_dir = tempfile.mkdtemp(prefix=__name__)
+    self.addCleanup(shutil.rmtree, working_dir)
+    standalone = StandaloneSlapOS(
+        working_dir, SLAPOS_TEST_IPV4, SLAPOS_TEST_PORT)
+    self.addCleanup(standalone.stop)
+    standalone.format(2, SLAPOS_TEST_IPV4, SLAPOS_TEST_IPV6)
+    standalone.format(1, SLAPOS_TEST_IPV4, SLAPOS_TEST_IPV6)
+    self.assertFalse(
+        os.path.exists(
+            os.path.join(standalone.instance_directory, 'slappart1')))
+    self.assertEqual(
+        ['slappart0'],
+        [cp.getId() for cp in standalone.computer.getComputerPartitionList()])
+
+  def test_reformat_different_base_name(self):
+    working_dir = tempfile.mkdtemp(prefix=__name__)
+    self.addCleanup(shutil.rmtree, working_dir)
+    standalone = StandaloneSlapOS(
+        working_dir, SLAPOS_TEST_IPV4, SLAPOS_TEST_PORT)
+    self.addCleanup(standalone.stop)
+    standalone.format(
+        1, SLAPOS_TEST_IPV4, SLAPOS_TEST_IPV6, partition_base_name="a")
+    self.assertTrue(
+        os.path.exists(os.path.join(standalone.instance_directory, 'a0')))
+    standalone.format(
+        1, SLAPOS_TEST_IPV4, SLAPOS_TEST_IPV6, partition_base_name="b")
+    self.assertFalse(
+        os.path.exists(os.path.join(standalone.instance_directory, 'a0')))
+    self.assertTrue(
+        os.path.exists(os.path.join(standalone.instance_directory, 'b0')))
+    self.assertEqual(
+        ['b0'],
+        [cp.getId() for cp in standalone.computer.getComputerPartitionList()])
+
+  def test_reformat_refuse_deleting_running_partition(self):
+    working_dir = tempfile.mkdtemp(prefix=__name__)
+    self.addCleanup(shutil.rmtree, working_dir)
+    standalone = StandaloneSlapOS(
+        working_dir, SLAPOS_TEST_IPV4, SLAPOS_TEST_PORT)
+    self.addCleanup(standalone.stop)
+    standalone.format(1, SLAPOS_TEST_IPV4, SLAPOS_TEST_IPV6)
+    with mock.patch("slapos.slap.ComputerPartition.getState", return_value="busy"),\
+       self.assertRaisesRegex(ValueError, "Cannot reformat to remove busy partition at .*slappart0"):
+      standalone.format(0, SLAPOS_TEST_IPV4, SLAPOS_TEST_IPV6)
+
+  def test_two_instance_from_same_directory(self):
+    working_dir = tempfile.mkdtemp(prefix=__name__)
+    self.addCleanup(shutil.rmtree, working_dir)
+    standalone1 = StandaloneSlapOS(
+        working_dir, SLAPOS_TEST_IPV4, SLAPOS_TEST_PORT)
+
+    def maybestop():
+      # try to stop anyway, not to leak processes if test fail
+      try:
+        standalone1.stop()
+      except:
+        pass
+
+    self.addCleanup(maybestop)
+
+    # create another class instance, will control the same standanlone slapos.
+    standalone2 = StandaloneSlapOS(
+        working_dir, SLAPOS_TEST_IPV4, SLAPOS_TEST_PORT)
+    standalone2.stop()
+
+    # stopping standalone2 stops everything
+    with self.assertRaises(BaseException):
+      standalone1.supply("https://example.com/software.cfg")
+    with self.assertRaises(BaseException):
+      standalone1.stop()
+
+
+class SlapOSStandaloneTestCase(unittest.TestCase):
+  # This test case takes care of stopping the standalone instance
+  # in a cleanup, but subclasses who needs to control shutdown
+  # can set this class attribute to False to prevent this behavior.
+  _auto_stop_standalone = True
+
+  def setUp(self):
+    checkPortIsFree()
+    working_dir = tempfile.mkdtemp(prefix=__name__)
+    self.addCleanup(shutil.rmtree, working_dir)
+    self.standalone = StandaloneSlapOS(
+        working_dir, SLAPOS_TEST_IPV4, SLAPOS_TEST_PORT)
+    if self._auto_stop_standalone:
+      self.addCleanup(self.standalone.stop)
+    self.standalone.format(1, SLAPOS_TEST_IPV4, SLAPOS_TEST_IPV6)
+
+
+class TestSlapOSStandaloneSoftware(SlapOSStandaloneTestCase):
+  def test_install_software(self):
+    with tempfile.NamedTemporaryFile(suffix="-%s.cfg" % self.id()) as f:
+      f.write(
+          textwrap.dedent(
+              '''
+              [buildout]
+              parts = instance
+              [instance]
+              recipe = plone.recipe.command==1.1
+              command = touch ${buildout:directory}/instance.cfg
+      ''').encode())
+      f.flush()
+      self.standalone.supply(f.name)
+      self.standalone.waitForSoftware()
+
+      software_hash = hashlib.md5(f.name.encode()).hexdigest()
+      software_installation_path = os.path.join(
+          self.standalone.software_directory, software_hash)
+      self.assertTrue(os.path.exists(software_installation_path))
+      self.assertTrue(
+          os.path.exists(os.path.join(software_installation_path, 'bin')))
+      self.assertTrue(
+          os.path.exists(os.path.join(software_installation_path, 'parts')))
+      self.assertTrue(
+          os.path.exists(
+              os.path.join(software_installation_path, '.completed')))
+      self.assertTrue(
+          os.path.exists(
+              os.path.join(software_installation_path, 'instance.cfg')))
+
+      # destroy
+      self.standalone.supply(f.name, state='destroyed')
+      self.standalone.waitForSoftware()
+      self.assertFalse(os.path.exists(software_installation_path))
+
+  def test_install_software_failure(self):
+    with tempfile.NamedTemporaryFile(suffix="-%s.cfg" % self.id()) as f:
+      f.write(
+          textwrap.dedent(
+              '''
+              [buildout]
+              parts = error
+              [error]
+              recipe = plone.recipe.command==1.1
+              command = bash -c "exit 123"
+              stop-on-error = true
+      ''').encode())
+      f.flush()
+      self.standalone.supply(f.name)
+
+      with self.assertRaises(SlapOSNodeCommandError) as e:
+        self.standalone.waitForSoftware()
+
+      self.assertEqual(1, e.exception.args[0]['exitstatus'])
+      self.assertIn(
+          "Error: Non zero exit code (123) while running command.",
+          e.exception.args[0]['output'])
+      # SlapOSNodeCommandError.__str__ also displays output nicely
+      self.assertIn(
+          "SlapOSNodeCommandError exitstatus: 1 output:", str(e.exception))
+      self.assertIn(
+          "Error: Non zero exit code (123) while running command.",
+          str(e.exception))
+      self.assertNotIn(r"\n", str(e.exception))
+
+
+class TestSlapOSStandaloneInstance(SlapOSStandaloneTestCase):
+  _auto_stop_standalone = False  # we stop explicitly
+
+  def test_request_instance(self):
+    with tempfile.NamedTemporaryFile(suffix="-%s.cfg" % self.id()) as f:
+      # This is a minimal / super fast buildout that's compatible with slapos.
+      # We don't want to install slapos.cookbook because installation takes too
+      # much time, so we use simple plone.recipe.command and shell.
+      # This buildout create an instance with two parts:
+      #  check_parameter: that checks that the requested parameter is set
+      #  publish: that publish some parameters so that we can assert it's published.
+      software_url = f.name
+      f.write(
+          textwrap.dedent(
+              '''
+              [buildout]
+              parts = instance
+
+              [instance]
+              recipe = plone.recipe.command==1.1
+              stop-on-error = true
+              # we use @@DOLLAR@@{section:option} for what will become instance substitutions
+              command = sed -e s/@@DOLLAR@@/$/g <<EOF > ${buildout:directory}/instance.cfg
+                [buildout]
+                parts = check_parameter publish
+                eggs-directory = ${buildout:eggs-directory}
+
+                [check_parameter]
+                # check we were requested with request=parameter ( as a way to test
+                # request parameters are sent )
+                recipe = plone.recipe.command==1.1
+                stop-on-error = true
+                command = \\
+                  curl '@@DOLLAR@@{slap-connection:server-url}/registerComputerPartition?computer_reference=@@DOLLAR@@{slap-connection:computer-id}&computer_partition_reference=@@DOLLAR@@{slap-connection:partition-id}' \\
+                  | grep '<string>request</string><string>parameter</string>'
+
+                [publish]
+                # touch a file to check instance exists and publish a hardcoded parameter
+                recipe = plone.recipe.command==1.1
+                stop-on-error = true
+                command = \\
+                  touch instance.check \\
+                    && curl -X POST @@DOLLAR@@{slap-connection:server-url}/setComputerPartitionConnectionXml \\
+                    -d computer_id=@@DOLLAR@@{slap-connection:computer-id} \\
+                    -d computer_partition_id=@@DOLLAR@@{slap-connection:partition-id} \\
+                    -d connection_xml='<dictionary><string>published</string><string>parameter</string></dictionary>'
+                EOF
+      ''').encode())
+      f.flush()
+
+      self.standalone.supply(software_url)
+      self.standalone.waitForSoftware()
+
+    self.standalone.request(
+        software_url,
+        'default',
+        'instance',
+        partition_parameter_kw={'request': 'parameter'})
+    self.standalone.waitForInstance()
+
+    # check published parameters
+    partition = self.standalone.request(
+        software_url,
+        'default',
+        'instance',
+        partition_parameter_kw={'request': 'parameter'})
+    self.assertEqual({'published': 'parameter'},
+                     partition.getConnectionParameterDict())
+
+    # check instance files
+    parition_directory = os.path.join(
+        self.standalone.instance_directory, 'slappart0')
+    self.assertTrue(
+        os.path.exists(os.path.join(parition_directory, '.installed.cfg')))
+    self.assertTrue(
+        os.path.exists(os.path.join(parition_directory, 'instance.check')))
+
+    # check instance supervisor, there should be only watchdog now
+    with self.standalone.instance_supervisor_rpc as instance_supervisor_rpc:
+      self.assertEqual(
+          ['watchdog'],
+          [p['name'] for p in instance_supervisor_rpc.getAllProcessInfo()])
+
+    # delete instance
+    self.standalone.request(
+        software_url,
+        'default',
+        'instance',
+        partition_parameter_kw={'partition': 'parameter'},
+        state='destroyed',
+    )
+    self.standalone.waitForInstance()
+    # instanciate does nothing, it will be deleted with `report`
+    self.assertTrue(
+        os.path.exists(os.path.join(parition_directory, 'instance.check')))
+    self.standalone.waitForReport()
+    self.assertFalse(
+        os.path.exists(os.path.join(parition_directory, 'instance.check')))
+
+    # check that stopping leaves no process
+    process_list = []
+    with self.standalone.instance_supervisor_rpc as instance_supervisor_rpc:
+      process_list.append(psutil.Process(instance_supervisor_rpc.getPID()))
+      process_list.extend([
+          psutil.Process(p['pid'])
+          for p in instance_supervisor_rpc.getAllProcessInfo()
+          if p['statename'] == 'RUNNING'
+      ])
+    with self.standalone.system_supervisor_rpc as system_supervisor_rpc:
+      process_list.append(psutil.Process(system_supervisor_rpc.getPID()))
+      process_list.extend([
+          psutil.Process(p['pid'])
+          for p in system_supervisor_rpc.getAllProcessInfo()
+          if p['statename'] == 'RUNNING'
+      ])
+    self.assertEqual(set([True]), set([p.is_running() for p in process_list]))
+    self.standalone.stop()
+    self.assertEqual(set([False]), set([p.is_running() for p in process_list]))