caddy-frontend: Test cases

Features:

 * forcediphttpsadapter for SNI
 * compatbile with apache-frontend SR
 * local server to test against

software/caddy-frontend/test/README.md

+Tests for ProFTPd software release

software/caddy-frontend/test/customdomainsslcrtsslkey.example.com.crt

+-----BEGIN CERTIFICATE-----
+MIIDuzCCAqOgAwIBAgIJAOzw6rzXAd+jMA0GCSqGSIb3DQEBCwUAMHQxCzAJBgNV
+BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX
+aWRnaXRzIFB0eSBMdGQxLTArBgNVBAMMJGN1c3RvbWRvbWFpbnNzbGNydHNzbGtl
+eS5leGFtcGxlLmNvbTAeFw0xODA1MTgxMzA2NThaFw0yODA1MTUxMzA2NThaMHQx
+CzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRl
+cm5ldCBXaWRnaXRzIFB0eSBMdGQxLTArBgNVBAMMJGN1c3RvbWRvbWFpbnNzbGNy
+dHNzbGtleS5leGFtcGxlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
+ggEBAOQe3WLRuVBPPufClmlOk6Euc3nmycvCkzcwMUD6+zdyAGH0qhHoIHJmiXi6
+GcKYgqqa3eaIxvvke2EEphDwYkj6neOVyuX3KukL8ggEUakJ17TEQkS7hIk4dmDT
+wjFAMgLz8uN11jqLooo9w/ptD+LUWmm6K9zk49iqqdKuG9Z5v3dm0KMUvsmYGWqN
+g31tQWU1Cm2kNu+2iP2FPnx2PWkDq4KTn64U7iJP9DdDEvzNfYcvz8upjR15B+dI
+K0ihwDXV5BtfZXDvck+ctCdfS1QxM+x+PboEJKUNoefz/+Q/9T3mlc+KchFG9asL
+Q/kbHtdgZzsDGTDEtdDtIrLLQ3MCAwEAAaNQME4wHQYDVR0OBBYEFG6I5Y0feayi
+UPznSzRJIMS1blcNMB8GA1UdIwQYMBaAFG6I5Y0feayiUPznSzRJIMS1blcNMAwG
+A1UdEwQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAKmK75LcaROfjdxQLBFqiP/I
+6WB8pBNbAN6nL+dgxeQJNEx7VQXSU/3KF0nIMC35pzf93ZySMq6ujCjxksNA0Pa0
+XEH0pmTqOO7Af5wsjIniLqGTRvFCqGbWKEcYDBwKq0svTGfYyPOaBj8z7lt9LURs
+WRC1tCrn8T8NkAY/jdGRQZRtLlgk+x2SaeDfQ8F1MtMT8jYSLo4R+c4f+iuDgMWi
+JPM5SvYeDEXndWctKGxmP4p2HIp8gJuqYHmP4oxO7Rn/QPti1p68WfNQsRquHYJ4
+dR9krkpVeteQ7w8cQA9OkG/m3neiIfFKkosJSGEHctRvRQ0GtbQO6A6nZqk0n6I=
+-----END CERTIFICATE-----

software/caddy-frontend/test/customdomainsslcrtsslkey.example.com.key

+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDkHt1i0blQTz7n
+wpZpTpOhLnN55snLwpM3MDFA+vs3cgBh9KoR6CByZol4uhnCmIKqmt3miMb75Hth
+BKYQ8GJI+p3jlcrl9yrpC/IIBFGpCde0xEJEu4SJOHZg08IxQDIC8/LjddY6i6KK
+PcP6bQ/i1Fppuivc5OPYqqnSrhvWeb93ZtCjFL7JmBlqjYN9bUFlNQptpDbvtoj9
+hT58dj1pA6uCk5+uFO4iT/Q3QxL8zX2HL8/LqY0deQfnSCtIocA11eQbX2Vw73JP
+nLQnX0tUMTPsfj26BCSlDaHn8//kP/U95pXPinIRRvWrC0P5Gx7XYGc7AxkwxLXQ
+7SKyy0NzAgMBAAECggEBAOLv5ZPCSdWgEFdlWFbIycrmOBDETGo9VlDny4f2ZuZg
+rgrE6E/KGkVUxlvo32mcaRkp2ajW1wWN5kO86Swex9gMIfhfcyrVecW/kXbyPP6q
+AQIe4EIaPh54oiNvZleyok4Xu8EW4Bj8AqX+DjHaP5yLXqqhf7NPrW9FUI57kMwK
+DqeHBilgWUxzcjc4LLiEu6UTuB8c2Slj3Ps0K/mVzvPbQ7Xx+RYXzfX+SqjyvDEe
+GpaRLoiRJ0KZSoGUgBQSIqgfzR7g6ipKNDvlzsawMpG641vsQ8tSI+l4U5f6MbYZ
+pFT+mxL4+N+PQbWN5w3qYWK6Ilh77+0rKfGVrLH7s7kCgYEA/2SXFnUgJUnKpuE0
+4buUtPCMw8j+qZsJZ8nmf2BbwIGgp+CFGlO6aG4sfzYulpQuZOsnKRIu5qoE3xQp
+MzuqWPZ8eygAubBdddaym3kPRiMAxTXPr+vBFyvti+oFflxaTsTXAfCXD2wM8yKm
+Od16xg9co3NED2zt62mtSM6NOiUCgYEA5Kmt1JqL4ymMe9gBZ07Ar7GCfmmqepSb
+w9XqgkHDk0ZYizNeQupPQrypfdeLFlKVnlp4DycEA4XzGdFgp1+PkAMSIVDUZZp5
+KxWJdQkdScENe1eYAz0vALCWSnUahyMGuNW9Xe/z2mtNLKRYcNDQ2LROJTQjShvw
+XSfVQXS597cCgYEAgXG5hn9tAJlLJpQk2njZ4W++2QkJ0msrNDjIJC1xs7u/8vbA
+X9yqMX4N/Zg3ush2T15EpfN6ZB0uhObSDw6hw5+C7mUTIQq8BBsCwfx0+maJYGtq
+zc6fOqBgMTc2+5nRh/UKyQfpeL6aPa2FNPUF4lcs7AdjKrJaUKRqWOmf+SUCgYAd
+ksRkpshIzOraaYlk7w6EqpSR/OCLkgTDQztdNVwyA/sXpcEfLmap3vScze+zJ2Mq
+Y9D7RLSEMCLMyAOUIgvTOFJz9JxDt8LMC7EHbfJXw5wWw7FpWdRmZnBJmPOhXqpT
+5XDkYVBMg2wrxeWaUadxH4Cr1x5pS0u/AJPYL1yN6QKBgApwfVmCWXS0S1++6KiM
+WN+jyvqmF4FS6Ib5TII1/diChY0PCO/UnmVPYg1AIqsdT5ghVreZs7wuHi1LsXQ4
+41nBmUnhdaiKCz9qVybXJwvicn/2MlsIi5C4Ox97OHJyCR1iKxf5A2ypfYEuh25V
+NZZ4n9p5PhcLev6x3QhuWosT
+-----END PRIVATE KEY-----

software/caddy-frontend/test/setup.py

+##############################################################################
+#
+# Copyright (c) 2018 Nexedi SA 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 advised 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.
+#
+##############################################################################
+from setuptools import setup, find_packages
+
+version = '0.0.1.dev0'
+name = 'slapos.test.caddy-frontend'
+long_description = open("README.md").read()
+
+setup(name=name,
+      version=version,
+      description="Test for SlapOS' Caddy Frontend",
+      long_description=long_description,
+      long_description_content_type='text/markdown',
+      maintainer="Nexedi",
+      maintainer_email="info@nexedi.com",
+      url="https://lab.nexedi.com/nexedi/slapos",
+      packages=find_packages(),
+      install_requires=[
+        'slapos.core',
+        'erp5.util',
+        'requests',
+        'forcediphttpsadapter',
+        'supervisor',
+      ],
+      zip_safe=True,
+      test_suite='test',
+      )

software/caddy-frontend/test/test.py

+##############################################################################
+#
+# Copyright (c) 2018 Nexedi SA 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 advised 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 requests
+import json
+import multiprocessing
+import subprocess
+from unittest import skipIf
+from BaseHTTPServer import HTTPServer
+from forcediphttpsadapter.adapters import ForcedIPHTTPSAdapter
+
+import utils
+
+
+# ports chosen to not collide with test systems
+HTTP_PORT = '11080'
+HTTPS_PORT = '11443'
+NGINX_HTTP_PORT = '12080'
+NGINX_HTTPS_PORT = '12443'
+MONITOR_HTTPD_PORT = '13000'
+
+
+if os.environ['TEST_SR'].endswith('caddy-frontend/software.cfg'):
+  IS_CADDY = True
+else:
+  IS_CADDY = False
+
+# response_code difference
+if IS_CADDY:
+  no_backend_response_code = 404
+else:
+  no_backend_response_code = 502
+
+# apache_custom_http[s] difference
+if IS_CADDY:
+  LOG_REGEXP = '^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3} SOME_REMOTE_USER ' \
+      '\[\d{2}\/.{3}\/\d{4}\:\d{2}\:\d{2}\:\d{2} \+\d{4}\] ' \
+      '"GET \/test-path HTTP\/1.1" 404 \d+ "-" "python-requests.*" \d+'
+  apache_custom_https = '''# apache_custom_https_filled_in_accepted
+https://apachecustomhttpsaccepted.example.com:%%(https_port)s {
+  bind %%(local_ipv4)s
+  tls %%(ssl_crt)s %%(ssl_key)s
+
+  log / %%(access_log)s {combined}
+  errors %%(error_log)s
+
+  proxy / %(url)s {
+    transparent
+    timeout 600s
+    insecure_skip_verify
+  }
+}
+'''
+  apache_custom_http = '''# apache_custom_http_filled_in_accepted
+http://apachecustomhttpsaccepted.example.com:%%(http_port)s {
+  bind %%(local_ipv4)s
+  log / %%(access_log)s {combined}
+  errors %%(error_log)s
+
+  proxy / %(url)s {
+    transparent
+    timeout 600s
+    insecure_skip_verify
+  }
+}
+'''
+else:
+  LOG_REGEXP = '^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3} - - ' \
+      '\[\d{2}\/.{3}\/\d{4}\:\d{2}\:\d{2}\:\d{2} \+\d{4}\] ' \
+      '"GET \/test-path HTTP\/1.1" 502 \d+ "-" "python-requests.*" \d+'
+  apache_custom_https = '''# apache_custom_https_filled_in_accepted
+ServerName apachecustomhttpsaccepted.example.com
+ServerAlias apachecustomhttpsaccepted.example.com
+SSLEngine on
+SSLProxyEngine on
+
+ErrorLog %%(error_log)s
+LogLevel notice
+CustomLog %%(access_log)s combined
+
+# Rewrite part
+ProxyPreserveHost On
+ProxyTimeout 600
+RewriteEngine On
+
+RewriteRule ^/(.*)$ %(url)s/$1 [L,P]
+'''
+  apache_custom_http = '''# apache_custom_http_filled_in_accpeted
+ServerName apachecustomhttpsaccepted.example.com
+ServerAlias apachecustomhttpsaccepted.example.com
+
+ErrorLog %%(error_log)s
+LogLevel notice
+CustomLog %%(access_log)s combined
+
+# Rewrite part
+ProxyPreserveHost On
+ProxyTimeout 600
+RewriteEngine On
+
+RewriteRule ^/(.*)$ %(url)s/$1 [L,P]
+'''
+
+# for development: debugging logs and install Ctrl+C handler
+if os.environ.get('DEBUG'):
+  import logging
+  logging.basicConfig(level=logging.DEBUG)
+  import unittest
+  unittest.installHandler()
+
+
+def isHTTP2(domain, ip):
+  curl_command = '%(curl)s --http2 -v -k -H "Host: %(domain)s" ' \
+    'https://%(domain)s:%(https_port)s/ '\
+    '--resolve %(domain)s:%(https_port)s:%(ip)s' % dict(
+      ip=ip, domain=domain, curl=os.environ['CURL'], https_port=HTTPS_PORT)
+  prc = subprocess.Popen(
+    curl_command.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE
+  )
+  out, err = prc.communicate()
+  assert prc.returncode == 0, "Problem running %r. Output:\n%s\nError:\n%s" % (
+    curl_command, out, err)
+  return 'Using HTTP2, server supports multi-use' in err
+
+
+class TestDataMixin(object):
+  def getTrimmedProcessInfo(self):
+    return '\n'.join(sorted([
+      '%(group)s:%(name)s %(statename)s' % q for q
+      in self.getSupervisorRPCServer().supervisor.getAllProcessInfo()]))
+
+  def assertTestData(self, runtime_data):
+    filename = '%s-%s.txt' % (self.id(), self.frontend_type)
+    test_data_file = os.path.join(
+      os.path.dirname(os.path.realpath(__file__)), 'test_data', filename)
+
+    try:
+      test_data = open(test_data_file).read().strip()
+    except IOError:
+      test_data = ''
+
+    maxDiff = self.maxDiff
+    self.maxDiff = None
+    try:
+      self.assertMultiLineEqual(
+        test_data,
+        runtime_data
+      )
+    except AssertionError:
+      if os.environ.get('SAVE_TEST_DATA', '0') == '1':
+        open(test_data_file, 'w').write(runtime_data.strip())
+      raise
+    finally:
+      self.maxDiff = maxDiff
+
+  def test_promise_list(self):
+    runtime_data = '\n'.join(sorted([
+      q[len(self.instance_path) + 1:]
+      for q in glob.glob(os.path.join(
+        self.instance_path, '*', 'etc', 'promise', '*'))]))
+
+    self.assertTestData(runtime_data)
+
+  def test_monitor_promise_list(self):
+    runtime_data = '\n'.join(sorted([
+      q[len(self.instance_path) + 1:]
+      for q in glob.glob(os.path.join(
+        self.instance_path, '*', 'etc', 'monitor-promise', '*'))]))
+    self.assertTestData(runtime_data)
+
+  def test_supervisor_state(self):
+    runtime_data = self.getTrimmedProcessInfo()
+    self.assertTestData(runtime_data)
+
+
+class HttpFrontendTestCase(utils.SlapOSInstanceTestCase):
+  frontend_type = 'CADDY' if IS_CADDY else 'APACHE'
+
+  def assertLogAccessUrlWithPop(self, parameter_dict, reference):
+    log_access_url = parameter_dict.pop('log-access-url')
+    try:
+      log_access_url_json = json.loads(log_access_url)
+    except Exception:
+      raise ValueError('JSON decode problem in:\n%s' % (log_access_url,))
+
+    self.assertTrue(len(log_access_url_json) >= 1)
+    # check only the first one, as second frontend will be stopped
+    log_access = log_access_url_json[0]
+    entry = log_access.split(': ')
+    if len(entry) != 2:
+      self.fail('Cannot parse %r' % (log_access,))
+    frontend, url = entry
+    result = requests.get(url, verify=False)
+    self.assertEqual(
+      result.status_code,
+      200,
+      'While accessing %r of %r the status code was %r' % (
+        url, frontend, result.status_code))
+
+  def assertKeyWithPop(self, key, d):
+    self.assertTrue(key in d, 'Key %r is missing in %r' % (key, d))
+    d.pop(key)
+
+  def assertEqualResultJson(self, result, key, value):
+    try:
+      j = result.json()
+    except Exception:
+      raise ValueError('JSON decode problem in:\n%s' % (result.text,))
+    self.assertTrue(key in j, 'No key %r in %s' % (key, j))
+    self.assertEqual(j[key], value)
+
+
+class TestMasterRequest(HttpFrontendTestCase, TestDataMixin):
+  def test(self):
+    parameter_dict = self.computer_partition.getConnectionParameterDict()
+    self.assertKeyWithPop('monitor-setup-url', parameter_dict)
+    self.assertEqual(
+      {
+        'monitor-base-url': None,
+        'domain': 'None',
+        'accepted-slave-amount': '0',
+        'rejected-slave-amount': '0',
+        'slave-amount': '0',
+        'rejected-slave-list': '[]'},
+      parameter_dict
+    )
+
+
+class TestMasterRequestDomain(HttpFrontendTestCase, TestDataMixin):
+  @classmethod
+  def getInstanceParameterDict(cls):
+    return {
+      'domain': 'example.com',
+      'port': HTTPS_PORT,
+      'plain_http_port': HTTP_PORT,
+      'nginx_port': NGINX_HTTPS_PORT,
+      'plain_nginx_port': NGINX_HTTP_PORT,
+      'monitor-httpd-port': MONITOR_HTTPD_PORT,
+    }
+
+  def test(self):
+    parameter_dict = self.computer_partition.getConnectionParameterDict()
+    self.assertKeyWithPop('monitor-setup-url', parameter_dict)
+
+    self.assertEqual(
+      {
+        'monitor-base-url': None,
+        'domain': 'example.com',
+        'accepted-slave-amount': '0',
+        'rejected-slave-amount': '0',
+        'slave-amount': '0',
+        'rejected-slave-list': '[]'
+      },
+      parameter_dict
+    )
+
+
+class SlaveHttpFrontendTestCase(HttpFrontendTestCase):
+  @classmethod
+  def startServerProcess(cls):
+    server = HTTPServer(
+      (utils.LOCAL_IPV4, utils.findFreeTCPPort(utils.LOCAL_IPV4)),
+      utils.TestHandler)
+    cls.backend_url = 'http://%s:%s' % server.server_address
+    cls.server_process = multiprocessing.Process(target=server.serve_forever)
+    cls.server_process.start()
+
+  @classmethod
+  def stopServerProcess(cls):
+    cls.server_process.terminate()
+
+  @classmethod
+  def setUpSlaves(cls):
+    cls.slave_connection_parameter_dict_dict = {}
+    request = cls.slapos_controler.slap.registerOpenOrder().request
+    for slave_reference, partition_parameter_kw in cls\
+            .getSlaveParameterDictDict().items():
+      slave_instance = request(
+        software_release=cls.software_url_list[0],
+        partition_reference=slave_reference,
+        partition_parameter_kw=partition_parameter_kw,
+        shared=True
+      )
+    cls.runComputerPartition()
+    for slave_reference, partition_parameter_kw in cls\
+            .getSlaveParameterDictDict().items():
+      slave_instance = request(
+        software_release=cls.software_url_list[0],
+        partition_reference=slave_reference,
+        partition_parameter_kw=partition_parameter_kw,
+        shared=True
+      )
+      cls.slave_connection_parameter_dict_dict[slave_reference] = \
+          slave_instance.getConnectionParameterDict()
+
+  @classmethod
+  def setUpClass(cls):
+    try:
+      cls.startServerProcess()
+      super(SlaveHttpFrontendTestCase, cls).setUpClass()
+      cls.setUpSlaves()
+    except Exception:
+      cls.tearDownClass()
+      raise
+
+  @classmethod
+  def tearDownClass(cls):
+    super(SlaveHttpFrontendTestCase, cls).tearDownClass()
+    cls.stopServerProcess()
+
+  def fakeHTTPSResult(self, domain, real_ip, path, port=HTTPS_PORT,
+                      headers=None, cookies=None):
+    if headers is None:
+      headers = {}
+    headers.setdefault('REMOTE_USER', 'SOME_REMOTE_USER')
+    session = requests.Session()
+    session.mount(
+      'https://%s:%s' % (domain, port),
+      ForcedIPHTTPSAdapter(
+        dest_ip=real_ip))
+
+    return session.get(
+      'https://%s:%s/%s' % (domain, port, path),
+      verify=False,
+      allow_redirects=False,
+      headers=headers,
+      cookies=cookies
+    )
+
+  def fakeHTTPResult(self, domain, real_ip, path, port=HTTP_PORT,
+                     headers=None):
+    if headers is None:
+      headers = {}
+    headers.setdefault('REMOTE_USER', 'SOME_REMOTE_USER')
+    headers['Host'] = domain
+    return requests.get(
+      'http://%s:%s/%s' % (real_ip, port, path),
+      headers=headers,
+      allow_redirects=False,
+    )
+
+  def patchRequests(self):
+    HTTPResponse = requests.packages.urllib3.response.HTTPResponse
+    HTTPResponse.orig__init__ = HTTPResponse.__init__
+
+    def new_HTTPResponse__init__(self, *args, **kwargs):
+      self.orig__init__(*args, **kwargs)
+      try:
+        self.peercert = self._connection.sock.getpeercert(binary_form=True)
+      except AttributeError:
+        pass
+    HTTPResponse.__init__ = new_HTTPResponse__init__
+
+    HTTPAdapter = requests.adapters.HTTPAdapter
+    HTTPAdapter.orig_build_response = HTTPAdapter.build_response
+
+    def new_HTTPAdapter_build_response(self, request, resp):
+      response = self.orig_build_response(request, resp)
+      try:
+        response.peercert = resp.peercert
+      except AttributeError:
+        pass
+      return response
+    HTTPAdapter.build_response = new_HTTPAdapter_build_response
+
+  def unpatchRequests(self):
+    HTTPResponse = requests.packages.urllib3.response.HTTPResponse
+    if getattr(HTTPResponse, 'orig__init__', None) is not None:
+      HTTPResponse.__init__ = HTTPResponse.orig__init__
+      del(HTTPResponse.orig__init__)
+
+    HTTPAdapter = requests.adapters.HTTPAdapter
+    if getattr(HTTPAdapter, 'orig_build_response', None) is not None:
+      HTTPAdapter.build_response = HTTPAdapter.orig_build_response
+      del(HTTPAdapter.orig_build_response)
+
+  def setUp(self):
+    # patch requests in order to being able to extract SSL certs
+    self.patchRequests()
+
+  def tearDown(self):
+    self.unpatchRequests()
+
+
+class TestSlave(SlaveHttpFrontendTestCase, TestDataMixin):
+  @classmethod
+  def getInstanceParameterDict(cls):
+    return {
+      'domain': 'example.com',
+      'nginx-domain': 'nginx.example.com',
+      'public-ipv4': utils.LOCAL_IPV4,
+      'apache-certificate': open('wildcard.example.com.crt').read(),
+      'apache-key': open('wildcard.example.com.key').read(),
+      '-frontend-authorized-slave-string': '_apache_custom_http_s-accepted',
+      'port': HTTPS_PORT,
+      'plain_http_port': HTTP_PORT,
+      'nginx_port': NGINX_HTTPS_PORT,
+      'plain_nginx_port': NGINX_HTTP_PORT,
+      'monitor-httpd-port': MONITOR_HTTPD_PORT,
+    }
+
+  @classmethod
+  def getSlaveParameterDictDict(cls):
+    return {
+      'empty': {
+      },
+      'url': {
+        'url': cls.backend_url,
+      },
+      'url_https-url': {
+        'url': cls.backend_url + '/http',
+        'https-url': cls.backend_url + '/https',
+      },
+      'server-alias': {
+        'url': cls.backend_url,
+        'server-alias': 'alias1.example.com alias2.example.com',
+      },
+      'https-only': {
+        'url': cls.backend_url,
+        'https-only': True,
+      },
+      'custom_domain': {
+        'url': cls.backend_url,
+        'custom_domain': 'customdomain.example.com',
+      },
+      'custom_domain_ssl_crt_ssl_key': {
+        'url': cls.backend_url,
+        'custom_domain': 'customdomainsslcrtsslkey.example.com',
+        'ssl_crt': open('customdomainsslcrtsslkey.example.com.crt').read(),
+        'ssl_key': open('customdomainsslcrtsslkey.example.com.key').read(),
+      },
+      'type-zope': {
+        'url': cls.backend_url,
+        'type': 'zope',
+      },
+      'type-zope-virtualhostroot-http-port': {
+        'url': cls.backend_url,
+        'type': 'zope',
+        'virtualhostroot-http-port': '12345'
+      },
+      'type-zope-virtualhostroot-https-port': {
+        'url': cls.backend_url,
+        'type': 'zope',
+        'virtualhostroot-https-port': '12345'
+      },
+      'type-zope-path': {
+        'url': cls.backend_url,
+        'type': 'zope',
+        'path': 'path',
+      },
+      'type-zope-default-path': {
+        'url': cls.backend_url,
+        'type': 'zope',
+        'default-path': 'default-path',
+      },
+      'type-notebook': {
+        'url': cls.backend_url,
+        'type': 'notebook',
+      },
+      'type-eventsource': {
+        'url': cls.backend_url,
+        'type': 'eventsource',
+      },
+      'type-redirect': {
+        'url': cls.backend_url,
+        'type': 'redirect',
+      },
+      'enable_cache': {
+        'url': cls.backend_url,
+        'enable_cache': True,
+      },
+      'enable_cache-disable-no-cache-request': {
+        'url': cls.backend_url,
+        'enable_cache': True,
+        'disable-no-cache-request': True,
+      },
+      'enable_cache-disable-via-header': {
+        'url': cls.backend_url,
+        'enable_cache': True,
+        'disable-via-header': True,
+      },
+      'enable-http2-false': {
+        'url': cls.backend_url,
+        'enable-http2': False,
+      },
+      'enable-http2-default': {
+        'url': cls.backend_url,
+      },
+      'apache_custom_http_s-rejected': {
+        'url': cls.backend_url,
+        'apache_custom_https': '# apache_custom_https_filled_in_rejected',
+        'apache_custom_http': '# apache_custom_http_filled_in_rejected',
+      },
+      'apache_custom_http_s-accepted': {
+        'url': cls.backend_url,
+        'apache_custom_https': apache_custom_https % dict(url=cls.backend_url),
+        'apache_custom_http': apache_custom_http % dict(url=cls.backend_url),
+      },
+      'prefer-gzip-encoding-to-backend': {
+        'url': cls.backend_url,
+        'prefer-gzip-encoding-to-backend': 'true',
+      },
+      'disabled-cookie-list': {
+        'url': cls.backend_url,
+        'disabled-cookie-list': 'Chocolate Vanilia',
+      },
+      'monitor-ipv4-test': {
+        'monitor-ipv4-test': 'monitor-ipv4-test',
+      },
+      'monitor-ipv6-test': {
+        'monitor-ipv6-test': 'monitor-ipv6-test',
+      },
+      're6st-optimal-test': {
+        're6st-optimal-test': 'ipv6,ipv4',
+      }
+    }
+
+  def getMasterPartitionPath(self):
+    # partition w/o etc/trafficserver, but with buildout.cfg
+    return [
+      q for q in glob.glob(os.path.join(self.instance_path, '*',))
+      if not os.path.exists(os.path.join(q, 'etc', 'trafficserver')) and
+      os.path.exists(os.path.join(q, 'buildout.cfg'))][0]
+
+  def getSlavePartitionPath(self):
+    # partition w/ etc/trafficserver
+    return [
+      q for q in glob.glob(os.path.join(self.instance_path, '*',))
+      if os.path.exists(os.path.join(q, 'etc', 'trafficserver'))][0]
+
+  def test_master_partition_state(self):
+    parameter_dict = self.computer_partition.getConnectionParameterDict()
+    self.assertKeyWithPop('monitor-setup-url', parameter_dict)
+
+    self.assertEqual(
+      {
+        'monitor-base-url': None,
+        'domain': 'example.com',
+        'accepted-slave-amount': '26',
+        'rejected-slave-amount': '1',
+        'slave-amount': '27',
+        'rejected-slave-list': '["_apache_custom_http_s-rejected"]'},
+      parameter_dict
+    )
+
+    partition_path = self.getMasterPartitionPath()
+
+    self.assertEqual(
+      set([
+        'check-free-disk-space',
+        'monitor-http-frontend',
+        'monitor-httpd-listening-on-tcp',
+        'promise-monitor-httpd-is-process-older-than-dependency-set',
+      ]),
+      set(os.listdir(os.path.join(partition_path, 'etc', 'promise'))))
+
+    self.assertEqual(
+      set(),
+      set(os.listdir(os.path.join(partition_path, 'etc', 'monitor-promise'))))
+
+  def test_empty(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'empty']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'empty')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'empty.example.com',
+        'replication_number': '1',
+        'url': 'http://empty.example.com',
+        'site_url': 'http://empty.example.com',
+        'secure_access': 'https://empty.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqual(result.status_code, no_backend_response_code)
+
+    # check that log file contains verbose log
+    log_file = glob.glob(
+      os.path.join(
+        self.instance_path, '*', 'var', 'log', 'httpd', '_empty_access_log'
+      ))[0]
+
+    self.assertRegexpMatches(
+      open(log_file, 'r').read(),
+      LOG_REGEXP)
+    result_http = self.fakeHTTPResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+    self.assertEqual(result_http.status_code, no_backend_response_code)
+
+    # check that 404 is as configured
+    result_missing = self.fakeHTTPSResult(
+      'forsuredoesnotexists.example.com', parameter_dict['public-ipv4'], '')
+    self.assertEqual(404, result_missing.status_code)
+    self.assertEqual(
+      """<html>
+<head>
+  <title>Instance not found</title>
+</head>
+<body>
+<h1>This instance has not been found.</h1>
+<p>If this error persists, please check your instance URL and status on S"""
+      """lapOS Master.</p>
+</body>
+</html>
+""",
+      result_missing.text
+    )
+
+  def test_url(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'url']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'url')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'url.example.com',
+        'replication_number': '1',
+        'url': 'http://url.example.com',
+        'site_url': 'http://url.example.com',
+        'secure_access': 'https://url.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+    try:
+      j = result.json()
+    except Exception:
+      raise ValueError('JSON decode problem in:\n%s' % (result.text,))
+    self.assertFalse('remote_user' in j['Incoming Headers'].keys())
+
+    self.assertEqual(
+      result.headers['Set-Cookie'],
+      'secured=value;secure, nonsecured=value'
+    )
+
+    result_http = self.fakeHTTPResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+    self.assertEqualResultJson(result_http, 'Path', '/test-path')
+
+    try:
+      j = result_http.json()
+    except Exception:
+      raise ValueError('JSON decode problem in:\n%s' % (result.text,))
+    self.assertFalse('remote_user' in j['Incoming Headers'].keys())
+
+    self.assertEqual(
+      result_http.headers['Set-Cookie'],
+      'secured=value;secure, nonsecured=value'
+    )
+
+    result_ipv6 = self.fakeHTTPSResult(
+      parameter_dict['domain'], utils.GLOBAL_IPV6, 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result_ipv6.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result_ipv6, 'Path', '/test-path')
+
+  def test_type_zope_path(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'type-zope-path']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'type-zope-path')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'typezopepath.example.com',
+        'replication_number': '1',
+        'url': 'http://typezopepath.example.com',
+        'site_url': 'http://typezopepath.example.com',
+        'secure_access': 'https://typezopepath.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(
+      result,
+      'Path',
+      '/VirtualHostBase/https//'
+      'typezopepath.example.com:443/path/VirtualHostRoot/test-path'
+    )
+
+  def test_type_zope_default_path(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'type-zope-default-path']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'type-zope-default-path')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'typezopedefaultpath.example.com',
+        'replication_number': '1',
+        'url': 'http://typezopedefaultpath.example.com',
+        'site_url': 'http://typezopedefaultpath.example.com',
+        'secure_access': 'https://typezopedefaultpath.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], '')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqual(
+      result.headers['Location'],
+      'https://typezopedefaultpath.example.com:%s/default-path' % (HTTPS_PORT,)
+    )
+
+  def test_server_alias(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'server-alias']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'server-alias')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'serveralias.example.com',
+        'replication_number': '1',
+        'url': 'http://serveralias.example.com',
+        'site_url': 'http://serveralias.example.com',
+        'secure_access': 'https://serveralias.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+    result = self.fakeHTTPSResult(
+      'alias1.example.com', parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+    result = self.fakeHTTPSResult(
+      'alias2.example.com', parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+  @skipIf(IS_CADDY, 'Feature postponed')
+  def test_path_to_ssl_ca_crt(self):
+    raise NotImplementedError(self.id())
+
+  def test_https_only(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'https-only']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'https-only')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'httpsonly.example.com',
+        'replication_number': '1',
+        'url': 'http://httpsonly.example.com',
+        'site_url': 'http://httpsonly.example.com',
+        'secure_access': 'https://httpsonly.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+    result_http = self.fakeHTTPResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      result_http.headers['Location'],
+      'https://httpsonly.example.com/test-path'
+    )
+
+  def test_custom_domain(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'custom_domain']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'custom_domain')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'customdomain.example.com',
+        'replication_number': '1',
+        'url': 'http://customdomain.example.com',
+        'site_url': 'http://customdomain.example.com',
+        'secure_access': 'https://customdomain.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+  def test_custom_domain_ssl_crt_ssl_key(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'custom_domain_ssl_crt_ssl_key']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'custom_domain_ssl_crt_key')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'customdomainsslcrtsslkey.example.com',
+        'replication_number': '1',
+        'url': 'http://customdomainsslcrtsslkey.example.com',
+        'site_url': 'http://customdomainsslcrtsslkey.example.com',
+        'secure_access': 'https://customdomainsslcrtsslkey.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('customdomainsslcrtsslkey.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+  def test_type_zope(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'type-zope']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'type-zope')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'typezope.example.com',
+        'replication_number': '1',
+        'url': 'http://typezope.example.com',
+        'site_url': 'http://typezope.example.com',
+        'secure_access': 'https://typezope.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    try:
+      j = result.json()
+    except Exception:
+      raise ValueError('JSON decode problem in:\n%s' % (result.text,))
+    self.assertFalse('remote_user' in j['Incoming Headers'].keys())
+
+    self.assertEqualResultJson(
+      result,
+      'Path',
+      '/VirtualHostBase/https//typezope.example.com:443/'
+      '/VirtualHostRoot/test-path'
+    )
+
+    result = self.fakeHTTPResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqualResultJson(
+      result,
+      'Path',
+      '/VirtualHostBase/http//typezope.example.com:80/'
+      '/VirtualHostRoot/test-path'
+    )
+
+  def test_type_zope_virtualhostroot_http_port(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'type-zope-virtualhostroot-http-port']
+    self.assertLogAccessUrlWithPop(
+      parameter_dict, 'type-zope-virtualhostroot-http-port')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'typezopevirtualhostroothttpport.example.com',
+        'replication_number': '1',
+        'url': 'http://typezopevirtualhostroothttpport.example.com',
+        'site_url': 'http://typezopevirtualhostroothttpport.example.com',
+        'secure_access':
+        'https://typezopevirtualhostroothttpport.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqualResultJson(
+      result,
+      'Path',
+      '/VirtualHostBase/http//typezopevirtualhostroothttpport'
+      '.example.com:12345//VirtualHostRoot/test-path'
+    )
+
+  def test_type_zope_virtualhostroot_https_port(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'type-zope-virtualhostroot-https-port']
+    self.assertLogAccessUrlWithPop(
+      parameter_dict, 'type-zope-virtualhostroot-https-port')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'typezopevirtualhostroothttpsport.example.com',
+        'replication_number': '1',
+        'url': 'http://typezopevirtualhostroothttpsport.example.com',
+        'site_url': 'http://typezopevirtualhostroothttpsport.example.com',
+        'secure_access':
+        'https://typezopevirtualhostroothttpsport.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(
+      result,
+      'Path',
+      '/VirtualHostBase/https//typezopevirtualhostroothttpsport'
+      '.example.com:12345//VirtualHostRoot/test-path'
+    )
+
+  def test_type_notebook(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'type-notebook']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'type-notebook')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'typenotebook.nginx.example.com',
+        'replication_number': '1',
+        'url': 'http://typenotebook.nginx.example.com',
+        'site_url': 'http://typenotebook.nginx.example.com',
+        'secure_access': 'https://typenotebook.nginx.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path',
+      NGINX_HTTPS_PORT)
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+  @skipIf(IS_CADDY, 'Feature postponed')
+  def test_type_eventsource(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'type-eventsource']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'type-eventsource')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'typeeventsource.nginx.example.com',
+        'replication_number': '1',
+        'url': 'http://typeeventsource.nginx.example.com',
+        'site_url': 'http://typeeventsource.nginx.example.com',
+        'secure_access': 'https://typeeventsource.nginx.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'pub',
+      NGINX_HTTPS_PORT)
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqual(
+      result.content,
+      ''
+    )
+    headers = result.headers.copy()
+    self.assertKeyWithPop('Expires', headers)
+    self.assertKeyWithPop('Date', headers)
+    self.assertEqual(
+      headers,
+      {
+        'X-Nginx-PushStream-Explain': 'No channel id provided.',
+        'Content-Length': '0',
+        'Cache-Control': 'no-cache, no-store, must-revalidate',
+        'Connection': 'keep-alive',
+        'Server': 'nginx'
+      }
+    )
+
+  def test_type_redirect(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'type-redirect']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'type-redirect')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'typeredirect.example.com',
+        'replication_number': '1',
+        'url': 'http://typeredirect.example.com',
+        'site_url': 'http://typeredirect.example.com',
+        'secure_access': 'https://typeredirect.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqual(
+      result.headers['Location'],
+      '%s/test-path' % (self.backend_url,)
+    )
+
+  @skipIf(IS_CADDY, 'Test not implemented')
+  def test_ssl_proxy_verify(self):
+    raise NotImplementedError(self.id())
+
+  @skipIf(IS_CADDY, 'Test not implemented')
+  def test_ssl_proxy_verify_ssl_proxy_ca_crt(self):
+    raise NotImplementedError(self.id())
+
+  def test_monitor_ipv6_test(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'monitor-ipv6-test']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'monitor-ipv6-test')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'monitoripv6test.example.com',
+        'replication_number': '1',
+        'url': 'http://monitoripv6test.example.com',
+        'site_url': 'http://monitoripv6test.example.com',
+        'secure_access': 'https://monitoripv6test.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqual(result.status_code, no_backend_response_code)
+
+    result_http = self.fakeHTTPResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+    self.assertEqual(result_http.status_code, no_backend_response_code)
+
+    # rewrite SR/bin/is-icmp-packet-lost
+    open(
+      os.path.join(self.software_path, 'bin', 'is-icmp-packet-lost'), 'w'
+    ).write('echo "$@"')
+    # call the monitor for this partition
+    monitor_file = glob.glob(
+      os.path.join(
+        self.instance_path, '*', 'etc', 'monitor-promise',
+        'check-_monitor-ipv6-test-ipv6-packet-list-test'))[0]
+    self.assertEqual(
+      '-a monitor-ipv6-test',
+      subprocess.check_output(monitor_file).strip()
+    )
+
+  def test_monitor_ipv4_test(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'monitor-ipv4-test']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'monitor-ipv4-test')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'monitoripv4test.example.com',
+        'replication_number': '1',
+        'url': 'http://monitoripv4test.example.com',
+        'site_url': 'http://monitoripv4test.example.com',
+        'secure_access': 'https://monitoripv4test.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqual(result.status_code, no_backend_response_code)
+
+    result_http = self.fakeHTTPResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+    self.assertEqual(result_http.status_code, no_backend_response_code)
+
+    # rewrite SR/bin/is-icmp-packet-lost
+    open(
+      os.path.join(self.software_path, 'bin', 'is-icmp-packet-lost'), 'w'
+    ).write('echo "$@"')
+    # call the monitor for this partition
+    monitor_file = glob.glob(
+      os.path.join(
+        self.instance_path, '*', 'etc', 'monitor-promise',
+        'check-_monitor-ipv4-test-ipv4-packet-list-test'))[0]
+    self.assertEqual(
+      '-4 -a monitor-ipv4-test',
+      subprocess.check_output(monitor_file).strip()
+    )
+
+  def test_re6st_optimal_test(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      're6st-optimal-test']
+    self.assertLogAccessUrlWithPop(parameter_dict, 're6st-optimal-test')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 're6stoptimaltest.example.com',
+        'replication_number': '1',
+        'url': 'http://re6stoptimaltest.example.com',
+        'site_url': 'http://re6stoptimaltest.example.com',
+        'secure_access': 'https://re6stoptimaltest.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqual(result.status_code, no_backend_response_code)
+
+    result_http = self.fakeHTTPResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+    self.assertEqual(result_http.status_code, no_backend_response_code)
+
+    # rewrite SR/bin/is-icmp-packet-lost
+    open(
+      os.path.join(
+        self.software_path, 'bin', 'check-re6st-optimal-status'), 'w'
+    ).write('echo "$@"')
+    # call the monitor for this partition
+    monitor_file = glob.glob(
+      os.path.join(
+        self.instance_path, '*', 'etc', 'monitor-promise',
+        'check-_re6st-optimal-test-re6st-optimal-test'))[0]
+    self.assertEqual(
+      '-4 ipv4 -6 ipv6',
+      subprocess.check_output(monitor_file).strip()
+    )
+
+  def test_enable_cache(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'enable_cache']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'enable_cache')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'enablecache.example.com',
+        'replication_number': '1',
+        'url': 'http://enablecache.example.com',
+        'site_url': 'http://enablecache.example.com',
+        'secure_access': 'https://enablecache.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+    headers = result.headers.copy()
+
+    self.assertKeyWithPop('Via', headers)
+    self.assertKeyWithPop('Server', headers)
+    self.assertKeyWithPop('Date', headers)
+
+    # drop keys appearing randomly in headers
+    headers.pop('Transfer-Encoding', None)
+    headers.pop('Content-Length', None)
+    headers.pop('Connection', None)
+    headers.pop('Keep-Alive', None)
+
+    self.assertEqual(
+      headers,
+      {'Age': '0', 'Content-type': 'text/json',
+       'Set-Cookie': 'secured=value;secure, nonsecured=value'}
+    )
+
+  def test_enable_cache_disable_no_cache_request(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'enable_cache-disable-no-cache-request']
+    self.assertLogAccessUrlWithPop(
+      parameter_dict, 'enable_cache-disable-no-cache-request')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'enablecachedisablenocacherequest.example.com',
+        'replication_number': '1',
+        'url': 'http://enablecachedisablenocacherequest.example.com',
+        'site_url': 'http://enablecachedisablenocacherequest.example.com',
+        'secure_access':
+        'https://enablecachedisablenocacherequest.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path',
+      headers={'Pragma': 'no-cache', 'Cache-Control': 'something'})
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+    headers = result.headers.copy()
+
+    self.assertKeyWithPop('Via', headers)
+    self.assertKeyWithPop('Server', headers)
+    self.assertKeyWithPop('Date', headers)
+
+    # drop keys appearing randomly in headers
+    headers.pop('Transfer-Encoding', None)
+    headers.pop('Content-Length', None)
+    headers.pop('Connection', None)
+    headers.pop('Keep-Alive', None)
+
+    self.assertEqual(
+      headers,
+      {'Age': '0', 'Content-type': 'text/json',
+       'Set-Cookie': 'secured=value;secure, nonsecured=value'}
+    )
+
+    try:
+      j = result.json()
+    except Exception:
+      raise ValueError('JSON decode problem in:\n%s' % (result.text,))
+    self.assertFalse('pragma' in j['Incoming Headers'].keys())
+
+  def test_enable_cache_disable_via_header(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'enable_cache-disable-via-header']
+    self.assertLogAccessUrlWithPop(
+      parameter_dict, 'enable_cache-disable-via-header')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'enablecachedisableviaheader.example.com',
+        'replication_number': '1',
+        'url': 'http://enablecachedisableviaheader.example.com',
+        'site_url': 'http://enablecachedisableviaheader.example.com',
+        'secure_access':
+        'https://enablecachedisableviaheader.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+    headers = result.headers.copy()
+
+    self.assertKeyWithPop('Server', headers)
+    self.assertKeyWithPop('Date', headers)
+
+    # drop keys appearing randomly in headers
+    headers.pop('Transfer-Encoding', None)
+    headers.pop('Content-Length', None)
+    headers.pop('Connection', None)
+    headers.pop('Keep-Alive', None)
+
+    self.assertEqual(
+      headers,
+      {'Age': '0', 'Content-type': 'text/json',
+       'Set-Cookie': 'secured=value;secure, nonsecured=value'}
+    )
+
+  def test_enable_http2_false(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'enable-http2-false']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'enable-http2-false')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'enablehttp2false.example.com',
+        'replication_number': '1',
+        'url': 'http://enablehttp2false.example.com',
+        'site_url': 'http://enablehttp2false.example.com',
+        'secure_access':
+        'https://enablehttp2false.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+    headers = result.headers.copy()
+
+    self.assertKeyWithPop('Server', headers)
+    self.assertKeyWithPop('Date', headers)
+
+    # drop vary-keys
+    headers.pop('Content-Length', None)
+    headers.pop('Transfer-Encoding', None)
+    headers.pop('Connection', None)
+    headers.pop('Keep-Alive', None)
+
+    self.assertEqual(
+      headers,
+      {
+        'Content-Type': 'text/json',
+        'Set-Cookie': 'secured=value;secure, nonsecured=value'
+      }
+    )
+
+    self.assertFalse(
+      isHTTP2(parameter_dict['domain'], parameter_dict['public-ipv4']))
+
+  def test_enable_http2_default(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'enable-http2-default']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'enable-http2-default')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'enablehttp2default.example.com',
+        'replication_number': '1',
+        'url': 'http://enablehttp2default.example.com',
+        'site_url': 'http://enablehttp2default.example.com',
+        'secure_access':
+        'https://enablehttp2default.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+    headers = result.headers.copy()
+
+    self.assertKeyWithPop('Server', headers)
+    self.assertKeyWithPop('Date', headers)
+
+    # drop vary-keys
+    headers.pop('Content-Length', None)
+    headers.pop('Transfer-Encoding', None)
+    headers.pop('Connection', None)
+    headers.pop('Keep-Alive', None)
+
+    self.assertEqual(
+      headers,
+      {
+        'Content-type': 'text/json',
+        'Set-Cookie': 'secured=value;secure, nonsecured=value'
+      }
+    )
+
+    self.assertTrue(
+      isHTTP2(parameter_dict['domain'], parameter_dict['public-ipv4']))
+
+  @skipIf(IS_CADDY, 'Feature postponed')
+  def test_prefer_gzip_encoding_to_backend(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'prefer-gzip-encoding-to-backend']
+    self.assertLogAccessUrlWithPop(
+      parameter_dict, 'prefer-gzip-encoding-to-backend')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'prefergzipencodingtobackend.example.com',
+        'replication_number': '1',
+        'url': 'http://prefergzipencodingtobackend.example.com',
+        'site_url': 'http://prefergzipencodingtobackend.example.com',
+        'secure_access':
+        'https://prefergzipencodingtobackend.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path',
+      headers={'Accept-Encoding': 'gzip, deflate'})
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+    self.assertEqual(
+      result.json()['Incoming Headers']['accept-encoding'], 'gzip')
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path',
+      headers={'Accept-Encoding': 'deflate'})
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+    self.assertEqual(
+      result.json()['Incoming Headers']['accept-encoding'], 'deflate')
+
+  @skipIf(IS_CADDY, 'Feature postponed')
+  def test_disabled_cookie_list(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'disabled-cookie-list']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'disabled-cookie-list')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'disabledcookielist.example.com',
+        'replication_number': '1',
+        'url': 'http://disabledcookielist.example.com',
+        'site_url': 'http://disabledcookielist.example.com',
+        'secure_access': 'https://disabledcookielist.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path',
+      cookies=dict(
+          Chocolate='absent',
+          Vanilia='absent',
+          Coffee='present'
+        ))
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+    self.assertEqual(
+      result.json()['Incoming Headers']['cookie'], 'Coffee=present')
+
+  def test_apache_custom_http_s_rejected(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'apache_custom_http_s-rejected']
+    self.assertEqual({}, parameter_dict)
+    slave_configuration_file_list = glob.glob(os.path.join(
+      self.instance_path, '*', 'etc', '*slave-conf.d', '*.conf'))
+    # no configuration file contains provided custom http
+    configuration_file_with_custom_https_list = [
+      q for q in slave_configuration_file_list
+      if 'apache_custom_https_filled_in_rejected' in open(q).read()]
+    self.assertEqual([], configuration_file_with_custom_https_list)
+
+    configuration_file_with_custom_http_list = [
+      q for q in slave_configuration_file_list
+      if 'apache_custom_http_filled_in_rejected' in open(q).read()]
+    self.assertEqual([], configuration_file_with_custom_http_list)
+
+  def test_apache_custom_http_s_accepted(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'apache_custom_http_s-accepted']
+    self.assertLogAccessUrlWithPop(
+      parameter_dict, 'apache_custom_http_s-accepted')
+    self.assertEqual(
+      parameter_dict,
+      {'replication_number': '1', 'public-ipv4': utils.LOCAL_IPV4}
+    )
+
+    result = self.fakeHTTPSResult(
+      'apachecustomhttpsaccepted.example.com',
+      parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+    headers = result.headers.copy()
+
+    self.assertKeyWithPop('Server', headers)
+    self.assertKeyWithPop('Date', headers)
+
+    # drop vary-keys
+    headers.pop('Content-Length', None)
+    headers.pop('Transfer-Encoding', None)
+    headers.pop('Connection', None)
+    headers.pop('Keep-Alive', None)
+
+    self.assertEqual(
+      headers,
+      {
+        'Content-type': 'text/json',
+        'Set-Cookie': 'secured=value;secure, nonsecured=value'
+      }
+    )
+
+    result_http = self.fakeHTTPResult(
+      'apachecustomhttpsaccepted.example.com',
+      parameter_dict['public-ipv4'], 'test-path')
+    self.assertEqualResultJson(result_http, 'Path', '/test-path')
+
+    slave_configuration_file_list = glob.glob(os.path.join(
+      self.instance_path, '*', 'etc', '*slave-conf.d', '*.conf'))
+    # no configuration file contains provided custom http
+    configuration_file_with_custom_https_list = [
+      q for q in slave_configuration_file_list
+      if 'apache_custom_https_filled_in_accepted' in open(q).read()]
+    self.assertEqual(1, len(configuration_file_with_custom_https_list))
+
+    configuration_file_with_custom_http_list = [
+      q for q in slave_configuration_file_list
+      if 'apache_custom_https_filled_in_accepted' in open(q).read()]
+    self.assertEqual(1, len(configuration_file_with_custom_http_list))
+
+  def test_https_url(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'url_https-url']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'url_https-url')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'urlhttpsurl.example.com',
+        'replication_number': '1',
+        'url': 'http://urlhttpsurl.example.com',
+        'site_url': 'http://urlhttpsurl.example.com',
+        'secure_access': 'https://urlhttpsurl.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/https/test-path')
+
+    result_http = self.fakeHTTPResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+    self.assertEqualResultJson(result_http, 'Path', '/http/test-path')
+
+
+class TestReplicateSlave(SlaveHttpFrontendTestCase, TestDataMixin):
+  @classmethod
+  def getInstanceParameterDict(cls):
+    return {
+      'domain': 'example.com',
+      'nginx-domain': 'nginx.example.com',
+      'public-ipv4': utils.LOCAL_IPV4,
+      'apache-certificate': open('wildcard.example.com.crt').read(),
+      'apache-key': open('wildcard.example.com.key').read(),
+      '-frontend-quantity': 2,
+      '-sla-2-computer_guid': 'slapos.test',
+      '-frontend-2-state': 'stopped',
+      'port': HTTPS_PORT,
+      'plain_http_port': HTTP_PORT,
+      'nginx_port': NGINX_HTTPS_PORT,
+      'plain_nginx_port': NGINX_HTTP_PORT,
+      'monitor-httpd-port': MONITOR_HTTPD_PORT,
+    }
+
+  @classmethod
+  def getSlaveParameterDictDict(cls):
+    return {
+      'replicate': {
+        'url': cls.backend_url,
+      },
+    }
+
+  def test(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'replicate']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'replicate')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'replicate.example.com',
+        'replication_number': '2',
+        'url': 'http://replicate.example.com',
+        'site_url': 'http://replicate.example.com',
+        'secure_access': 'https://replicate.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    result = self.fakeHTTPSResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+
+    self.assertEqual(
+      utils.der2pem(result.peercert),
+      open('wildcard.example.com.crt').read())
+
+    self.assertEqualResultJson(result, 'Path', '/test-path')
+
+    result_http = self.fakeHTTPResult(
+      parameter_dict['domain'], parameter_dict['public-ipv4'], 'test-path')
+    self.assertEqualResultJson(result_http, 'Path', '/test-path')
+
+    # prove 2nd frontend by inspection of the instance
+    slave_configuration_name = '_replicate.conf'
+    slave_configuration_file_list = [
+      '/'.join([f[0], slave_configuration_name]) for f in [
+        q for q in os.walk(self.instance_path)
+        if slave_configuration_name in q[2]
+      ]
+    ]
+
+    self.assertEqual(
+      2, len(slave_configuration_file_list), slave_configuration_file_list)
+
+
+class TestEnableHttp2ByDefaultFalseSlave(SlaveHttpFrontendTestCase,
+                                         TestDataMixin):
+  @classmethod
+  def getInstanceParameterDict(cls):
+    return {
+      'domain': 'example.com',
+      'nginx-domain': 'nginx.example.com',
+      'public-ipv4': utils.LOCAL_IPV4,
+      'apache-certificate': open('wildcard.example.com.crt').read(),
+      'apache-key': open('wildcard.example.com.key').read(),
+      'enable-http2-by-default': 'false',
+      'port': HTTPS_PORT,
+      'plain_http_port': HTTP_PORT,
+      'nginx_port': NGINX_HTTPS_PORT,
+      'plain_nginx_port': NGINX_HTTP_PORT,
+      'monitor-httpd-port': MONITOR_HTTPD_PORT,
+    }
+
+  @classmethod
+  def getSlaveParameterDictDict(cls):
+    return {
+      'enable-http2-default': {
+      },
+      'enable-http2-false': {
+        'enable-http2': 'false',
+      },
+      'enable-http2-true': {
+        'enable-http2': 'true',
+      },
+    }
+
+  def test_enable_http2_default(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'enable-http2-default']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'enable-http2-default')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'enablehttp2default.example.com',
+        'replication_number': '1',
+        'url': 'http://enablehttp2default.example.com',
+        'site_url': 'http://enablehttp2default.example.com',
+        'secure_access':
+        'https://enablehttp2default.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    self.assertFalse(
+      isHTTP2(parameter_dict['domain'], parameter_dict['public-ipv4']))
+
+  def test_enable_http2_false(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'enable-http2-false']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'enable-http2-false')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'enablehttp2false.example.com',
+        'replication_number': '1',
+        'url': 'http://enablehttp2false.example.com',
+        'site_url': 'http://enablehttp2false.example.com',
+        'secure_access':
+        'https://enablehttp2false.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    self.assertFalse(
+      isHTTP2(parameter_dict['domain'], parameter_dict['public-ipv4']))
+
+  def test_enable_http2_true(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'enable-http2-true']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'enable-http2-true')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'enablehttp2true.example.com',
+        'replication_number': '1',
+        'url': 'http://enablehttp2true.example.com',
+        'site_url': 'http://enablehttp2true.example.com',
+        'secure_access':
+        'https://enablehttp2true.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    self.assertTrue(
+      isHTTP2(parameter_dict['domain'], parameter_dict['public-ipv4']))
+
+
+class TestEnableHttp2ByDefaultDefaultSlave(SlaveHttpFrontendTestCase,
+                                           TestDataMixin):
+  @classmethod
+  def getInstanceParameterDict(cls):
+    return {
+      'domain': 'example.com',
+      'nginx-domain': 'nginx.example.com',
+      'public-ipv4': utils.LOCAL_IPV4,
+      'apache-certificate': open('wildcard.example.com.crt').read(),
+      'apache-key': open('wildcard.example.com.key').read(),
+      'port': HTTPS_PORT,
+      'plain_http_port': HTTP_PORT,
+      'nginx_port': NGINX_HTTPS_PORT,
+      'plain_nginx_port': NGINX_HTTP_PORT,
+      'monitor-httpd-port': MONITOR_HTTPD_PORT,
+    }
+
+  @classmethod
+  def getSlaveParameterDictDict(cls):
+    return {
+      'enable-http2-default': {
+      },
+      'enable-http2-false': {
+        'enable-http2': 'false',
+      },
+      'enable-http2-true': {
+        'enable-http2': 'true',
+      },
+    }
+
+  def test_enable_http2_default(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'enable-http2-default']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'enable-http2-default')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'enablehttp2default.example.com',
+        'replication_number': '1',
+        'url': 'http://enablehttp2default.example.com',
+        'site_url': 'http://enablehttp2default.example.com',
+        'secure_access':
+        'https://enablehttp2default.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    self.assertTrue(
+      isHTTP2(parameter_dict['domain'], parameter_dict['public-ipv4']))
+
+  def test_enable_http2_false(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'enable-http2-false']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'enable-http2-false')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'enablehttp2false.example.com',
+        'replication_number': '1',
+        'url': 'http://enablehttp2false.example.com',
+        'site_url': 'http://enablehttp2false.example.com',
+        'secure_access':
+        'https://enablehttp2false.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    self.assertFalse(
+      isHTTP2(parameter_dict['domain'], parameter_dict['public-ipv4']))
+
+  def test_enable_http2_true(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'enable-http2-true']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'enable-http2-true')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'enablehttp2true.example.com',
+        'replication_number': '1',
+        'url': 'http://enablehttp2true.example.com',
+        'site_url': 'http://enablehttp2true.example.com',
+        'secure_access':
+        'https://enablehttp2true.example.com',
+        'public-ipv4': utils.LOCAL_IPV4,
+      }
+    )
+
+    self.assertTrue(
+      isHTTP2(parameter_dict['domain'], parameter_dict['public-ipv4']))
+
+
+class TestRe6stVerificationUrlDefaultSlave(SlaveHttpFrontendTestCase,
+                                           TestDataMixin):
+  @classmethod
+  def getInstanceParameterDict(cls):
+    return {
+    }
+
+  @classmethod
+  def getSlaveParameterDictDict(cls):
+    return {
+      'default': {
+      },
+    }
+
+  def test_default(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'default']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'default')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'default.None',
+        'replication_number': '1',
+        'url': 'http://default.None',
+        'site_url': 'http://default.None',
+        'secure_access': 'https://default.None',
+        'public-ipv4': None,
+      }
+    )
+
+    re6st_connectivity_promise_list = glob.glob(
+      os.path.join(
+        self.instance_path, '*', 'etc', 'promise',
+        're6st-connectivity'))
+
+    self.assertEqual(1, len(re6st_connectivity_promise_list))
+
+    self.assertTrue(
+      'URL="http://[2001:67c:1254:4::1]/index.html"' in
+      open(re6st_connectivity_promise_list[0]).read()
+    )
+
+
+class TestRe6stVerificationUrlSlave(SlaveHttpFrontendTestCase,
+                                    TestDataMixin):
+  @classmethod
+  def getInstanceParameterDict(cls):
+    return {
+      're6st-verification-url': 'some-re6st-verification-url',
+    }
+
+  @classmethod
+  def getSlaveParameterDictDict(cls):
+    return {
+      'default': {
+      },
+    }
+
+  def test_default(self):
+    parameter_dict = self.slave_connection_parameter_dict_dict[
+      'default']
+    self.assertLogAccessUrlWithPop(parameter_dict, 'default')
+    self.assertEqual(
+      parameter_dict,
+      {
+        'domain': 'default.None',
+        'replication_number': '1',
+        'url': 'http://default.None',
+        'site_url': 'http://default.None',
+        'secure_access': 'https://default.None',
+        'public-ipv4': None,
+      }
+    )
+
+    re6st_connectivity_promise_list = glob.glob(
+      os.path.join(
+        self.instance_path, '*', 'etc', 'promise',
+        're6st-connectivity'))
+
+    self.assertEqual(1, len(re6st_connectivity_promise_list))
+
+    self.assertTrue(
+      'URL="some-re6st-verification-url"' in
+      open(re6st_connectivity_promise_list[0]).read()
+    )

software/caddy-frontend/test/test_data/test.TestEnableHttp2ByDefaultDefaultSlave.test_monitor_promise_list-APACHE.txt

+TestEnableHttp2ByDefaultDefaultSlave-1/etc/monitor-promise/check-_enable-http2-default-error-log-last-day
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/monitor-promise/check-_enable-http2-default-error-log-last-hour
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/monitor-promise/check-_enable-http2-false-error-log-last-day
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/monitor-promise/check-_enable-http2-false-error-log-last-hour
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/monitor-promise/check-_enable-http2-true-error-log-last-day
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/monitor-promise/check-_enable-http2-true-error-log-last-hour
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestEnableHttp2ByDefaultDefaultSlave.test_monitor_promise_list-CADDY.txt

+TestEnableHttp2ByDefaultDefaultSlave-1/etc/monitor-promise/check-_enable-http2-default-error-log-last-day
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/monitor-promise/check-_enable-http2-default-error-log-last-hour
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/monitor-promise/check-_enable-http2-false-error-log-last-day
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/monitor-promise/check-_enable-http2-false-error-log-last-hour
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/monitor-promise/check-_enable-http2-true-error-log-last-day
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/monitor-promise/check-_enable-http2-true-error-log-last-hour
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestEnableHttp2ByDefaultDefaultSlave.test_promise_list-APACHE.txt

+TestEnableHttp2ByDefaultDefaultSlave-0/etc/promise/check-free-disk-space
+TestEnableHttp2ByDefaultDefaultSlave-0/etc/promise/monitor-http-frontend
+TestEnableHttp2ByDefaultDefaultSlave-0/etc/promise/monitor-httpd-listening-on-tcp
+TestEnableHttp2ByDefaultDefaultSlave-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/apache-frontend-is-running-actual-software-release
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/apache-mpm-watchdog
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/apache_cached
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/apache_frontend_ipv4_http
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/apache_frontend_ipv4_https
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/apache_frontend_ipv6_http
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/apache_frontend_ipv6_https
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/apache_ssl_cached
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/check-free-disk-space
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/frontend-apache-configuration-promise
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/monitor-http-frontend
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/monitor-httpd-listening-on-tcp
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/nginx-configuration-promise
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/nginx_frontend_ipv4_http
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/nginx_frontend_ipv4_https
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/nginx_frontend_ipv6_http
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/nginx_frontend_ipv6_https
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/re6st-connectivity
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/trafficserver-cache-availability
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/trafficserver-port-listening
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestEnableHttp2ByDefaultDefaultSlave.test_promise_list-CADDY.txt

+TestEnableHttp2ByDefaultDefaultSlave-0/etc/promise/check-free-disk-space
+TestEnableHttp2ByDefaultDefaultSlave-0/etc/promise/monitor-http-frontend
+TestEnableHttp2ByDefaultDefaultSlave-0/etc/promise/monitor-httpd-listening-on-tcp
+TestEnableHttp2ByDefaultDefaultSlave-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/caddy-frontend-is-running-actual-software-release
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/caddy_cached
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/caddy_frontend_ipv4_http
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/caddy_frontend_ipv4_https
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/caddy_frontend_ipv6_http
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/caddy_frontend_ipv6_https
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/caddy_ssl_cached
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/check-free-disk-space
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/frontend-caddy-configuration-promise
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/monitor-http-frontend
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/monitor-httpd-listening-on-tcp
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/nginx-configuration-promise
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/nginx_frontend_ipv4_http
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/nginx_frontend_ipv4_https
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/nginx_frontend_ipv6_http
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/nginx_frontend_ipv6_https
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/re6st-connectivity
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/trafficserver-cache-availability
+TestEnableHttp2ByDefaultDefaultSlave-1/etc/promise/trafficserver-port-listening
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestEnableHttp2ByDefaultDefaultSlave.test_supervisor_state-APACHE.txt

+TestEnableHttp2ByDefaultDefaultSlave-0:bootstrap-monitor EXITED
+TestEnableHttp2ByDefaultDefaultSlave-0:certificate_authority-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-0:crond RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-0:monitor-httpd-graceful EXITED
+TestEnableHttp2ByDefaultDefaultSlave-0:monitor-httpd-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:bootstrap-monitor EXITED
+TestEnableHttp2ByDefaultDefaultSlave-1:certificate_authority-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:crond-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:frontend-apache-safe-graceful EXITED
+TestEnableHttp2ByDefaultDefaultSlave-1:frontend-nginx-safe-graceful EXITED
+TestEnableHttp2ByDefaultDefaultSlave-1:frontend_apache-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:frontend_nginx-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:monitor-httpd-graceful EXITED
+TestEnableHttp2ByDefaultDefaultSlave-1:monitor-httpd-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:trafficserver-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:trafficserver-reload EXITED
+watchdog:watchdog RUNNING
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestEnableHttp2ByDefaultDefaultSlave.test_supervisor_state-CADDY.txt

+TestEnableHttp2ByDefaultDefaultSlave-0:bootstrap-monitor EXITED
+TestEnableHttp2ByDefaultDefaultSlave-0:certificate_authority-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-0:crond RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-0:monitor-httpd-graceful EXITED
+TestEnableHttp2ByDefaultDefaultSlave-0:monitor-httpd-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:6tunnel-11080-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:6tunnel-11443-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:6tunnel-12080-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:6tunnel-12443-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:6tunnel-26011-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:6tunnel-26012-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:bootstrap-monitor EXITED
+TestEnableHttp2ByDefaultDefaultSlave-1:certificate_authority-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:crond-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:frontend-caddy-safe-graceful EXITED
+TestEnableHttp2ByDefaultDefaultSlave-1:frontend-nginx-safe-graceful EXITED
+TestEnableHttp2ByDefaultDefaultSlave-1:frontend_caddy-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:frontend_nginx-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:monitor-httpd-graceful EXITED
+TestEnableHttp2ByDefaultDefaultSlave-1:monitor-httpd-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:trafficserver-on-watch RUNNING
+TestEnableHttp2ByDefaultDefaultSlave-1:trafficserver-reload EXITED
+watchdog:watchdog RUNNING
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestEnableHttp2ByDefaultFalseSlave.test_monitor_promise_list-APACHE.txt

+TestEnableHttp2ByDefaultFalseSlave-1/etc/monitor-promise/check-_enable-http2-default-error-log-last-day
+TestEnableHttp2ByDefaultFalseSlave-1/etc/monitor-promise/check-_enable-http2-default-error-log-last-hour
+TestEnableHttp2ByDefaultFalseSlave-1/etc/monitor-promise/check-_enable-http2-false-error-log-last-day
+TestEnableHttp2ByDefaultFalseSlave-1/etc/monitor-promise/check-_enable-http2-false-error-log-last-hour
+TestEnableHttp2ByDefaultFalseSlave-1/etc/monitor-promise/check-_enable-http2-true-error-log-last-day
+TestEnableHttp2ByDefaultFalseSlave-1/etc/monitor-promise/check-_enable-http2-true-error-log-last-hour
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestEnableHttp2ByDefaultFalseSlave.test_monitor_promise_list-CADDY.txt

+TestEnableHttp2ByDefaultFalseSlave-1/etc/monitor-promise/check-_enable-http2-default-error-log-last-day
+TestEnableHttp2ByDefaultFalseSlave-1/etc/monitor-promise/check-_enable-http2-default-error-log-last-hour
+TestEnableHttp2ByDefaultFalseSlave-1/etc/monitor-promise/check-_enable-http2-false-error-log-last-day
+TestEnableHttp2ByDefaultFalseSlave-1/etc/monitor-promise/check-_enable-http2-false-error-log-last-hour
+TestEnableHttp2ByDefaultFalseSlave-1/etc/monitor-promise/check-_enable-http2-true-error-log-last-day
+TestEnableHttp2ByDefaultFalseSlave-1/etc/monitor-promise/check-_enable-http2-true-error-log-last-hour
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestEnableHttp2ByDefaultFalseSlave.test_promise_list-APACHE.txt

+TestEnableHttp2ByDefaultFalseSlave-0/etc/promise/check-free-disk-space
+TestEnableHttp2ByDefaultFalseSlave-0/etc/promise/monitor-http-frontend
+TestEnableHttp2ByDefaultFalseSlave-0/etc/promise/monitor-httpd-listening-on-tcp
+TestEnableHttp2ByDefaultFalseSlave-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/apache-frontend-is-running-actual-software-release
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/apache-mpm-watchdog
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/apache_cached
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/apache_frontend_ipv4_http
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/apache_frontend_ipv4_https
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/apache_frontend_ipv6_http
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/apache_frontend_ipv6_https
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/apache_ssl_cached
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/check-free-disk-space
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/frontend-apache-configuration-promise
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/monitor-http-frontend
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/monitor-httpd-listening-on-tcp
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/nginx-configuration-promise
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/nginx_frontend_ipv4_http
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/nginx_frontend_ipv4_https
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/nginx_frontend_ipv6_http
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/nginx_frontend_ipv6_https
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/re6st-connectivity
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/trafficserver-cache-availability
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/trafficserver-port-listening
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestEnableHttp2ByDefaultFalseSlave.test_promise_list-CADDY.txt

+TestEnableHttp2ByDefaultFalseSlave-0/etc/promise/check-free-disk-space
+TestEnableHttp2ByDefaultFalseSlave-0/etc/promise/monitor-http-frontend
+TestEnableHttp2ByDefaultFalseSlave-0/etc/promise/monitor-httpd-listening-on-tcp
+TestEnableHttp2ByDefaultFalseSlave-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/caddy-frontend-is-running-actual-software-release
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/caddy_cached
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/caddy_frontend_ipv4_http
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/caddy_frontend_ipv4_https
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/caddy_frontend_ipv6_http
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/caddy_frontend_ipv6_https
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/caddy_ssl_cached
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/check-free-disk-space
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/frontend-caddy-configuration-promise
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/monitor-http-frontend
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/monitor-httpd-listening-on-tcp
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/nginx-configuration-promise
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/nginx_frontend_ipv4_http
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/nginx_frontend_ipv4_https
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/nginx_frontend_ipv6_http
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/nginx_frontend_ipv6_https
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/re6st-connectivity
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/trafficserver-cache-availability
+TestEnableHttp2ByDefaultFalseSlave-1/etc/promise/trafficserver-port-listening
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestEnableHttp2ByDefaultFalseSlave.test_supervisor_state-APACHE.txt

+TestEnableHttp2ByDefaultFalseSlave-0:bootstrap-monitor EXITED
+TestEnableHttp2ByDefaultFalseSlave-0:certificate_authority-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-0:crond RUNNING
+TestEnableHttp2ByDefaultFalseSlave-0:monitor-httpd-graceful EXITED
+TestEnableHttp2ByDefaultFalseSlave-0:monitor-httpd-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:bootstrap-monitor EXITED
+TestEnableHttp2ByDefaultFalseSlave-1:certificate_authority-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:crond-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:frontend-apache-safe-graceful EXITED
+TestEnableHttp2ByDefaultFalseSlave-1:frontend-nginx-safe-graceful EXITED
+TestEnableHttp2ByDefaultFalseSlave-1:frontend_apache-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:frontend_nginx-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:monitor-httpd-graceful EXITED
+TestEnableHttp2ByDefaultFalseSlave-1:monitor-httpd-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:trafficserver-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:trafficserver-reload EXITED
+watchdog:watchdog RUNNING
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestEnableHttp2ByDefaultFalseSlave.test_supervisor_state-CADDY.txt

+TestEnableHttp2ByDefaultFalseSlave-0:bootstrap-monitor EXITED
+TestEnableHttp2ByDefaultFalseSlave-0:certificate_authority-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-0:crond RUNNING
+TestEnableHttp2ByDefaultFalseSlave-0:monitor-httpd-graceful EXITED
+TestEnableHttp2ByDefaultFalseSlave-0:monitor-httpd-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:6tunnel-11080-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:6tunnel-11443-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:6tunnel-12080-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:6tunnel-12443-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:6tunnel-26011-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:6tunnel-26012-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:bootstrap-monitor EXITED
+TestEnableHttp2ByDefaultFalseSlave-1:certificate_authority-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:crond-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:frontend-caddy-safe-graceful EXITED
+TestEnableHttp2ByDefaultFalseSlave-1:frontend-nginx-safe-graceful EXITED
+TestEnableHttp2ByDefaultFalseSlave-1:frontend_caddy-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:frontend_nginx-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:monitor-httpd-graceful EXITED
+TestEnableHttp2ByDefaultFalseSlave-1:monitor-httpd-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:trafficserver-on-watch RUNNING
+TestEnableHttp2ByDefaultFalseSlave-1:trafficserver-reload EXITED
+watchdog:watchdog RUNNING
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestMasterRequest.test_promise_list-APACHE.txt

+TestMasterRequest-0/etc/promise/check-free-disk-space
+TestMasterRequest-0/etc/promise/monitor-http-frontend
+TestMasterRequest-0/etc/promise/monitor-httpd-listening-on-tcp
+TestMasterRequest-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestMasterRequest-1/etc/promise/apache-frontend-is-running-actual-software-release
+TestMasterRequest-1/etc/promise/apache-mpm-watchdog
+TestMasterRequest-1/etc/promise/apache_cached
+TestMasterRequest-1/etc/promise/apache_frontend_ipv4_http
+TestMasterRequest-1/etc/promise/apache_frontend_ipv4_https
+TestMasterRequest-1/etc/promise/apache_frontend_ipv6_http
+TestMasterRequest-1/etc/promise/apache_frontend_ipv6_https
+TestMasterRequest-1/etc/promise/apache_ssl_cached
+TestMasterRequest-1/etc/promise/check-free-disk-space
+TestMasterRequest-1/etc/promise/frontend-apache-configuration-promise
+TestMasterRequest-1/etc/promise/monitor-http-frontend
+TestMasterRequest-1/etc/promise/monitor-httpd-listening-on-tcp
+TestMasterRequest-1/etc/promise/nginx-configuration-promise
+TestMasterRequest-1/etc/promise/nginx_frontend_ipv4_http
+TestMasterRequest-1/etc/promise/nginx_frontend_ipv4_https
+TestMasterRequest-1/etc/promise/nginx_frontend_ipv6_http
+TestMasterRequest-1/etc/promise/nginx_frontend_ipv6_https
+TestMasterRequest-1/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestMasterRequest-1/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestMasterRequest-1/etc/promise/re6st-connectivity
+TestMasterRequest-1/etc/promise/trafficserver-cache-availability
+TestMasterRequest-1/etc/promise/trafficserver-port-listening
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestMasterRequest.test_promise_list-CADDY.txt

+TestMasterRequest-0/etc/promise/check-free-disk-space
+TestMasterRequest-0/etc/promise/monitor-http-frontend
+TestMasterRequest-0/etc/promise/monitor-httpd-listening-on-tcp
+TestMasterRequest-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestMasterRequest-1/etc/promise/monitor-http-frontend
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestMasterRequest.test_supervisor_state-APACHE.txt

+TestMasterRequest-0:bootstrap-monitor EXITED
+TestMasterRequest-0:certificate_authority-on-watch RUNNING
+TestMasterRequest-0:crond RUNNING
+TestMasterRequest-0:monitor-httpd-graceful EXITED
+TestMasterRequest-0:monitor-httpd-on-watch RUNNING
+TestMasterRequest-1:bootstrap-monitor RUNNING
+TestMasterRequest-1:certificate_authority-on-watch RUNNING
+TestMasterRequest-1:crond-on-watch RUNNING
+TestMasterRequest-1:frontend-apache-safe-graceful EXITED
+TestMasterRequest-1:frontend-nginx-safe-graceful EXITED
+TestMasterRequest-1:frontend_apache-on-watch RUNNING
+TestMasterRequest-1:frontend_nginx-on-watch RUNNING
+TestMasterRequest-1:monitor-httpd-graceful EXITED
+TestMasterRequest-1:monitor-httpd-on-watch RUNNING
+TestMasterRequest-1:trafficserver-on-watch RUNNING
+TestMasterRequest-1:trafficserver-reload EXITED
+watchdog:watchdog RUNNING
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestMasterRequest.test_supervisor_state-CADDY.txt

+TestMasterRequest-0:bootstrap-monitor EXITED
+TestMasterRequest-0:certificate_authority-on-watch RUNNING
+TestMasterRequest-0:crond RUNNING
+TestMasterRequest-0:monitor-httpd-graceful EXITED
+TestMasterRequest-0:monitor-httpd-on-watch RUNNING
+watchdog:watchdog RUNNING

software/caddy-frontend/test/test_data/test.TestMasterRequestDomain.test_promise_list-APACHE.txt

+TestMasterRequestDomain-0/etc/promise/check-free-disk-space
+TestMasterRequestDomain-0/etc/promise/monitor-http-frontend
+TestMasterRequestDomain-0/etc/promise/monitor-httpd-listening-on-tcp
+TestMasterRequestDomain-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestMasterRequestDomain-1/etc/promise/apache-frontend-is-running-actual-software-release
+TestMasterRequestDomain-1/etc/promise/apache-mpm-watchdog
+TestMasterRequestDomain-1/etc/promise/apache_cached
+TestMasterRequestDomain-1/etc/promise/apache_frontend_ipv4_http
+TestMasterRequestDomain-1/etc/promise/apache_frontend_ipv4_https
+TestMasterRequestDomain-1/etc/promise/apache_frontend_ipv6_http
+TestMasterRequestDomain-1/etc/promise/apache_frontend_ipv6_https
+TestMasterRequestDomain-1/etc/promise/apache_ssl_cached
+TestMasterRequestDomain-1/etc/promise/check-free-disk-space
+TestMasterRequestDomain-1/etc/promise/frontend-apache-configuration-promise
+TestMasterRequestDomain-1/etc/promise/monitor-http-frontend
+TestMasterRequestDomain-1/etc/promise/monitor-httpd-listening-on-tcp
+TestMasterRequestDomain-1/etc/promise/nginx-configuration-promise
+TestMasterRequestDomain-1/etc/promise/nginx_frontend_ipv4_http
+TestMasterRequestDomain-1/etc/promise/nginx_frontend_ipv4_https
+TestMasterRequestDomain-1/etc/promise/nginx_frontend_ipv6_http
+TestMasterRequestDomain-1/etc/promise/nginx_frontend_ipv6_https
+TestMasterRequestDomain-1/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestMasterRequestDomain-1/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestMasterRequestDomain-1/etc/promise/re6st-connectivity
+TestMasterRequestDomain-1/etc/promise/trafficserver-cache-availability
+TestMasterRequestDomain-1/etc/promise/trafficserver-port-listening
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestMasterRequestDomain.test_promise_list-CADDY.txt

+TestMasterRequestDomain-0/etc/promise/check-free-disk-space
+TestMasterRequestDomain-0/etc/promise/monitor-http-frontend
+TestMasterRequestDomain-0/etc/promise/monitor-httpd-listening-on-tcp
+TestMasterRequestDomain-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestMasterRequestDomain-1/etc/promise/monitor-http-frontend
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestMasterRequestDomain.test_supervisor_state-APACHE.txt

+TestMasterRequestDomain-0:bootstrap-monitor EXITED
+TestMasterRequestDomain-0:certificate_authority-on-watch RUNNING
+TestMasterRequestDomain-0:crond RUNNING
+TestMasterRequestDomain-0:monitor-httpd-graceful EXITED
+TestMasterRequestDomain-0:monitor-httpd-on-watch RUNNING
+TestMasterRequestDomain-1:bootstrap-monitor RUNNING
+TestMasterRequestDomain-1:certificate_authority-on-watch RUNNING
+TestMasterRequestDomain-1:crond-on-watch RUNNING
+TestMasterRequestDomain-1:frontend-apache-safe-graceful EXITED
+TestMasterRequestDomain-1:frontend-nginx-safe-graceful EXITED
+TestMasterRequestDomain-1:frontend_apache-on-watch RUNNING
+TestMasterRequestDomain-1:frontend_nginx-on-watch RUNNING
+TestMasterRequestDomain-1:monitor-httpd-graceful EXITED
+TestMasterRequestDomain-1:monitor-httpd-on-watch RUNNING
+TestMasterRequestDomain-1:trafficserver-on-watch RUNNING
+TestMasterRequestDomain-1:trafficserver-reload EXITED
+watchdog:watchdog RUNNING
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestMasterRequestDomain.test_supervisor_state-CADDY.txt

+TestMasterRequestDomain-0:bootstrap-monitor EXITED
+TestMasterRequestDomain-0:certificate_authority-on-watch RUNNING
+TestMasterRequestDomain-0:crond RUNNING
+TestMasterRequestDomain-0:monitor-httpd-graceful EXITED
+TestMasterRequestDomain-0:monitor-httpd-on-watch RUNNING
+watchdog:watchdog RUNNING

software/caddy-frontend/test/test_data/test.TestRe6stVerificationUrlDefaultSlave.test_monitor_promise_list-APACHE.txt

+TestRe6stVerificationUrlDefaultSlave-1/etc/monitor-promise/check-_default-error-log-last-day
+TestRe6stVerificationUrlDefaultSlave-1/etc/monitor-promise/check-_default-error-log-last-hour
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestRe6stVerificationUrlDefaultSlave.test_monitor_promise_list-CADDY.txt

+TestRe6stVerificationUrlDefaultSlave-1/etc/monitor-promise/check-_default-error-log-last-day
+TestRe6stVerificationUrlDefaultSlave-1/etc/monitor-promise/check-_default-error-log-last-hour
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestRe6stVerificationUrlDefaultSlave.test_promise_list-APACHE.txt

+TestRe6stVerificationUrlDefaultSlave-0/etc/promise/check-free-disk-space
+TestRe6stVerificationUrlDefaultSlave-0/etc/promise/monitor-http-frontend
+TestRe6stVerificationUrlDefaultSlave-0/etc/promise/monitor-httpd-listening-on-tcp
+TestRe6stVerificationUrlDefaultSlave-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/apache-frontend-is-running-actual-software-release
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/apache-mpm-watchdog
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/apache_cached
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/apache_frontend_ipv4_http
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/apache_frontend_ipv4_https
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/apache_frontend_ipv6_http
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/apache_frontend_ipv6_https
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/apache_ssl_cached
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/check-free-disk-space
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/frontend-apache-configuration-promise
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/monitor-http-frontend
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/monitor-httpd-listening-on-tcp
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/nginx-configuration-promise
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/nginx_frontend_ipv4_http
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/nginx_frontend_ipv4_https
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/nginx_frontend_ipv6_http
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/nginx_frontend_ipv6_https
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/re6st-connectivity
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/trafficserver-cache-availability
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/trafficserver-port-listening
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestRe6stVerificationUrlDefaultSlave.test_promise_list-CADDY.txt

+TestRe6stVerificationUrlDefaultSlave-0/etc/promise/check-free-disk-space
+TestRe6stVerificationUrlDefaultSlave-0/etc/promise/monitor-http-frontend
+TestRe6stVerificationUrlDefaultSlave-0/etc/promise/monitor-httpd-listening-on-tcp
+TestRe6stVerificationUrlDefaultSlave-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/caddy-frontend-is-running-actual-software-release
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/caddy_cached
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/caddy_frontend_ipv4_http
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/caddy_frontend_ipv4_https
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/caddy_frontend_ipv6_http
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/caddy_frontend_ipv6_https
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/caddy_ssl_cached
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/check-free-disk-space
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/frontend-caddy-configuration-promise
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/monitor-http-frontend
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/monitor-httpd-listening-on-tcp
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/nginx-configuration-promise
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/nginx_frontend_ipv4_http
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/nginx_frontend_ipv4_https
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/nginx_frontend_ipv6_http
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/nginx_frontend_ipv6_https
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/re6st-connectivity
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/trafficserver-cache-availability
+TestRe6stVerificationUrlDefaultSlave-1/etc/promise/trafficserver-port-listening
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestRe6stVerificationUrlDefaultSlave.test_supervisor_state-APACHE.txt

+TestRe6stVerificationUrlDefaultSlave-0:bootstrap-monitor EXITED
+TestRe6stVerificationUrlDefaultSlave-0:certificate_authority-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-0:crond RUNNING
+TestRe6stVerificationUrlDefaultSlave-0:monitor-httpd-graceful EXITED
+TestRe6stVerificationUrlDefaultSlave-0:monitor-httpd-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:bootstrap-monitor RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:certificate_authority-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:crond-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:frontend-apache-safe-graceful EXITED
+TestRe6stVerificationUrlDefaultSlave-1:frontend-nginx-safe-graceful EXITED
+TestRe6stVerificationUrlDefaultSlave-1:frontend_apache-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:frontend_nginx-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:monitor-httpd-graceful EXITED
+TestRe6stVerificationUrlDefaultSlave-1:monitor-httpd-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:trafficserver-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:trafficserver-reload EXITED
+watchdog:watchdog RUNNING
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestRe6stVerificationUrlDefaultSlave.test_supervisor_state-CADDY.txt

+TestRe6stVerificationUrlDefaultSlave-0:bootstrap-monitor EXITED
+TestRe6stVerificationUrlDefaultSlave-0:certificate_authority-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-0:crond RUNNING
+TestRe6stVerificationUrlDefaultSlave-0:monitor-httpd-graceful EXITED
+TestRe6stVerificationUrlDefaultSlave-0:monitor-httpd-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:6tunnel-26011-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:6tunnel-26012-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:6tunnel-4443-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:6tunnel-8080-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:6tunnel-8081-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:6tunnel-9443-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:bootstrap-monitor RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:certificate_authority-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:crond-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:frontend-caddy-safe-graceful EXITED
+TestRe6stVerificationUrlDefaultSlave-1:frontend-nginx-safe-graceful EXITED
+TestRe6stVerificationUrlDefaultSlave-1:frontend_caddy-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:frontend_nginx-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:monitor-httpd-graceful EXITED
+TestRe6stVerificationUrlDefaultSlave-1:monitor-httpd-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:trafficserver-on-watch RUNNING
+TestRe6stVerificationUrlDefaultSlave-1:trafficserver-reload EXITED
+watchdog:watchdog RUNNING
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestRe6stVerificationUrlSlave.test_monitor_promise_list-APACHE.txt

+TestRe6stVerificationUrlSlave-1/etc/monitor-promise/check-_default-error-log-last-day
+TestRe6stVerificationUrlSlave-1/etc/monitor-promise/check-_default-error-log-last-hour
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestRe6stVerificationUrlSlave.test_monitor_promise_list-CADDY.txt

+TestRe6stVerificationUrlSlave-1/etc/monitor-promise/check-_default-error-log-last-day
+TestRe6stVerificationUrlSlave-1/etc/monitor-promise/check-_default-error-log-last-hour
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestRe6stVerificationUrlSlave.test_promise_list-APACHE.txt

+TestRe6stVerificationUrlSlave-0/etc/promise/check-free-disk-space
+TestRe6stVerificationUrlSlave-0/etc/promise/monitor-http-frontend
+TestRe6stVerificationUrlSlave-0/etc/promise/monitor-httpd-listening-on-tcp
+TestRe6stVerificationUrlSlave-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestRe6stVerificationUrlSlave-1/etc/promise/apache-frontend-is-running-actual-software-release
+TestRe6stVerificationUrlSlave-1/etc/promise/apache-mpm-watchdog
+TestRe6stVerificationUrlSlave-1/etc/promise/apache_cached
+TestRe6stVerificationUrlSlave-1/etc/promise/apache_frontend_ipv4_http
+TestRe6stVerificationUrlSlave-1/etc/promise/apache_frontend_ipv4_https
+TestRe6stVerificationUrlSlave-1/etc/promise/apache_frontend_ipv6_http
+TestRe6stVerificationUrlSlave-1/etc/promise/apache_frontend_ipv6_https
+TestRe6stVerificationUrlSlave-1/etc/promise/apache_ssl_cached
+TestRe6stVerificationUrlSlave-1/etc/promise/check-free-disk-space
+TestRe6stVerificationUrlSlave-1/etc/promise/frontend-apache-configuration-promise
+TestRe6stVerificationUrlSlave-1/etc/promise/monitor-http-frontend
+TestRe6stVerificationUrlSlave-1/etc/promise/monitor-httpd-listening-on-tcp
+TestRe6stVerificationUrlSlave-1/etc/promise/nginx-configuration-promise
+TestRe6stVerificationUrlSlave-1/etc/promise/nginx_frontend_ipv4_http
+TestRe6stVerificationUrlSlave-1/etc/promise/nginx_frontend_ipv4_https
+TestRe6stVerificationUrlSlave-1/etc/promise/nginx_frontend_ipv6_http
+TestRe6stVerificationUrlSlave-1/etc/promise/nginx_frontend_ipv6_https
+TestRe6stVerificationUrlSlave-1/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestRe6stVerificationUrlSlave-1/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestRe6stVerificationUrlSlave-1/etc/promise/re6st-connectivity
+TestRe6stVerificationUrlSlave-1/etc/promise/trafficserver-cache-availability
+TestRe6stVerificationUrlSlave-1/etc/promise/trafficserver-port-listening
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestRe6stVerificationUrlSlave.test_promise_list-CADDY.txt

+TestRe6stVerificationUrlSlave-0/etc/promise/check-free-disk-space
+TestRe6stVerificationUrlSlave-0/etc/promise/monitor-http-frontend
+TestRe6stVerificationUrlSlave-0/etc/promise/monitor-httpd-listening-on-tcp
+TestRe6stVerificationUrlSlave-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestRe6stVerificationUrlSlave-1/etc/promise/caddy-frontend-is-running-actual-software-release
+TestRe6stVerificationUrlSlave-1/etc/promise/caddy_cached
+TestRe6stVerificationUrlSlave-1/etc/promise/caddy_frontend_ipv4_http
+TestRe6stVerificationUrlSlave-1/etc/promise/caddy_frontend_ipv4_https
+TestRe6stVerificationUrlSlave-1/etc/promise/caddy_frontend_ipv6_http
+TestRe6stVerificationUrlSlave-1/etc/promise/caddy_frontend_ipv6_https
+TestRe6stVerificationUrlSlave-1/etc/promise/caddy_ssl_cached
+TestRe6stVerificationUrlSlave-1/etc/promise/check-free-disk-space
+TestRe6stVerificationUrlSlave-1/etc/promise/frontend-caddy-configuration-promise
+TestRe6stVerificationUrlSlave-1/etc/promise/monitor-http-frontend
+TestRe6stVerificationUrlSlave-1/etc/promise/monitor-httpd-listening-on-tcp
+TestRe6stVerificationUrlSlave-1/etc/promise/nginx-configuration-promise
+TestRe6stVerificationUrlSlave-1/etc/promise/nginx_frontend_ipv4_http
+TestRe6stVerificationUrlSlave-1/etc/promise/nginx_frontend_ipv4_https
+TestRe6stVerificationUrlSlave-1/etc/promise/nginx_frontend_ipv6_http
+TestRe6stVerificationUrlSlave-1/etc/promise/nginx_frontend_ipv6_https
+TestRe6stVerificationUrlSlave-1/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestRe6stVerificationUrlSlave-1/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestRe6stVerificationUrlSlave-1/etc/promise/re6st-connectivity
+TestRe6stVerificationUrlSlave-1/etc/promise/trafficserver-cache-availability
+TestRe6stVerificationUrlSlave-1/etc/promise/trafficserver-port-listening
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestRe6stVerificationUrlSlave.test_supervisor_state-APACHE.txt

+TestRe6stVerificationUrlSlave-0:bootstrap-monitor EXITED
+TestRe6stVerificationUrlSlave-0:certificate_authority-on-watch RUNNING
+TestRe6stVerificationUrlSlave-0:crond RUNNING
+TestRe6stVerificationUrlSlave-0:monitor-httpd-graceful EXITED
+TestRe6stVerificationUrlSlave-0:monitor-httpd-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:bootstrap-monitor RUNNING
+TestRe6stVerificationUrlSlave-1:certificate_authority-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:crond-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:frontend-apache-safe-graceful EXITED
+TestRe6stVerificationUrlSlave-1:frontend-nginx-safe-graceful EXITED
+TestRe6stVerificationUrlSlave-1:frontend_apache-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:frontend_nginx-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:monitor-httpd-graceful EXITED
+TestRe6stVerificationUrlSlave-1:monitor-httpd-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:trafficserver-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:trafficserver-reload EXITED
+watchdog:watchdog RUNNING
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestRe6stVerificationUrlSlave.test_supervisor_state-CADDY.txt

+TestRe6stVerificationUrlSlave-0:bootstrap-monitor EXITED
+TestRe6stVerificationUrlSlave-0:certificate_authority-on-watch RUNNING
+TestRe6stVerificationUrlSlave-0:crond RUNNING
+TestRe6stVerificationUrlSlave-0:monitor-httpd-graceful EXITED
+TestRe6stVerificationUrlSlave-0:monitor-httpd-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:6tunnel-26011-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:6tunnel-26012-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:6tunnel-4443-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:6tunnel-8080-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:6tunnel-8081-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:6tunnel-9443-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:bootstrap-monitor RUNNING
+TestRe6stVerificationUrlSlave-1:certificate_authority-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:crond-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:frontend-caddy-safe-graceful EXITED
+TestRe6stVerificationUrlSlave-1:frontend-nginx-safe-graceful EXITED
+TestRe6stVerificationUrlSlave-1:frontend_caddy-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:frontend_nginx-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:monitor-httpd-graceful EXITED
+TestRe6stVerificationUrlSlave-1:monitor-httpd-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:trafficserver-on-watch RUNNING
+TestRe6stVerificationUrlSlave-1:trafficserver-reload EXITED
+watchdog:watchdog RUNNING
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestReplicateSlave.test_monitor_promise_list-APACHE.txt

+TestReplicateSlave-1/etc/monitor-promise/check-_replicate-error-log-last-day
+TestReplicateSlave-1/etc/monitor-promise/check-_replicate-error-log-last-hour
+TestReplicateSlave-2/etc/monitor-promise/check-_replicate-error-log-last-day
+TestReplicateSlave-2/etc/monitor-promise/check-_replicate-error-log-last-hour
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestReplicateSlave.test_monitor_promise_list-CADDY.txt

+TestReplicateSlave-1/etc/monitor-promise/check-_replicate-error-log-last-day
+TestReplicateSlave-1/etc/monitor-promise/check-_replicate-error-log-last-hour
+TestReplicateSlave-2/etc/monitor-promise/check-_replicate-error-log-last-day
+TestReplicateSlave-2/etc/monitor-promise/check-_replicate-error-log-last-hour
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestReplicateSlave.test_promise_list-APACHE.txt

+TestReplicateSlave-0/etc/promise/check-free-disk-space
+TestReplicateSlave-0/etc/promise/monitor-http-frontend
+TestReplicateSlave-0/etc/promise/monitor-httpd-listening-on-tcp
+TestReplicateSlave-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestReplicateSlave-1/etc/promise/apache-frontend-is-running-actual-software-release
+TestReplicateSlave-1/etc/promise/apache-mpm-watchdog
+TestReplicateSlave-1/etc/promise/apache_cached
+TestReplicateSlave-1/etc/promise/apache_frontend_ipv4_http
+TestReplicateSlave-1/etc/promise/apache_frontend_ipv4_https
+TestReplicateSlave-1/etc/promise/apache_frontend_ipv6_http
+TestReplicateSlave-1/etc/promise/apache_frontend_ipv6_https
+TestReplicateSlave-1/etc/promise/apache_ssl_cached
+TestReplicateSlave-1/etc/promise/check-free-disk-space
+TestReplicateSlave-1/etc/promise/frontend-apache-configuration-promise
+TestReplicateSlave-1/etc/promise/monitor-http-frontend
+TestReplicateSlave-1/etc/promise/monitor-httpd-listening-on-tcp
+TestReplicateSlave-1/etc/promise/nginx-configuration-promise
+TestReplicateSlave-1/etc/promise/nginx_frontend_ipv4_http
+TestReplicateSlave-1/etc/promise/nginx_frontend_ipv4_https
+TestReplicateSlave-1/etc/promise/nginx_frontend_ipv6_http
+TestReplicateSlave-1/etc/promise/nginx_frontend_ipv6_https
+TestReplicateSlave-1/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestReplicateSlave-1/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestReplicateSlave-1/etc/promise/re6st-connectivity
+TestReplicateSlave-1/etc/promise/trafficserver-cache-availability
+TestReplicateSlave-1/etc/promise/trafficserver-port-listening
+TestReplicateSlave-2/etc/promise/apache-frontend-is-running-actual-software-release
+TestReplicateSlave-2/etc/promise/apache-mpm-watchdog
+TestReplicateSlave-2/etc/promise/apache_cached
+TestReplicateSlave-2/etc/promise/apache_frontend_ipv4_http
+TestReplicateSlave-2/etc/promise/apache_frontend_ipv4_https
+TestReplicateSlave-2/etc/promise/apache_frontend_ipv6_http
+TestReplicateSlave-2/etc/promise/apache_frontend_ipv6_https
+TestReplicateSlave-2/etc/promise/apache_ssl_cached
+TestReplicateSlave-2/etc/promise/check-free-disk-space
+TestReplicateSlave-2/etc/promise/frontend-apache-configuration-promise
+TestReplicateSlave-2/etc/promise/monitor-http-frontend
+TestReplicateSlave-2/etc/promise/monitor-httpd-listening-on-tcp
+TestReplicateSlave-2/etc/promise/nginx-configuration-promise
+TestReplicateSlave-2/etc/promise/nginx_frontend_ipv4_http
+TestReplicateSlave-2/etc/promise/nginx_frontend_ipv4_https
+TestReplicateSlave-2/etc/promise/nginx_frontend_ipv6_http
+TestReplicateSlave-2/etc/promise/nginx_frontend_ipv6_https
+TestReplicateSlave-2/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestReplicateSlave-2/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestReplicateSlave-2/etc/promise/re6st-connectivity
+TestReplicateSlave-2/etc/promise/trafficserver-cache-availability
+TestReplicateSlave-2/etc/promise/trafficserver-port-listening
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestReplicateSlave.test_promise_list-CADDY.txt

+TestReplicateSlave-0/etc/promise/check-free-disk-space
+TestReplicateSlave-0/etc/promise/monitor-http-frontend
+TestReplicateSlave-0/etc/promise/monitor-httpd-listening-on-tcp
+TestReplicateSlave-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestReplicateSlave-1/etc/promise/caddy-frontend-is-running-actual-software-release
+TestReplicateSlave-1/etc/promise/caddy_cached
+TestReplicateSlave-1/etc/promise/caddy_frontend_ipv4_http
+TestReplicateSlave-1/etc/promise/caddy_frontend_ipv4_https
+TestReplicateSlave-1/etc/promise/caddy_frontend_ipv6_http
+TestReplicateSlave-1/etc/promise/caddy_frontend_ipv6_https
+TestReplicateSlave-1/etc/promise/caddy_ssl_cached
+TestReplicateSlave-1/etc/promise/check-free-disk-space
+TestReplicateSlave-1/etc/promise/frontend-caddy-configuration-promise
+TestReplicateSlave-1/etc/promise/monitor-http-frontend
+TestReplicateSlave-1/etc/promise/monitor-httpd-listening-on-tcp
+TestReplicateSlave-1/etc/promise/nginx-configuration-promise
+TestReplicateSlave-1/etc/promise/nginx_frontend_ipv4_http
+TestReplicateSlave-1/etc/promise/nginx_frontend_ipv4_https
+TestReplicateSlave-1/etc/promise/nginx_frontend_ipv6_http
+TestReplicateSlave-1/etc/promise/nginx_frontend_ipv6_https
+TestReplicateSlave-1/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestReplicateSlave-1/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestReplicateSlave-1/etc/promise/re6st-connectivity
+TestReplicateSlave-1/etc/promise/trafficserver-cache-availability
+TestReplicateSlave-1/etc/promise/trafficserver-port-listening
+TestReplicateSlave-2/etc/promise/caddy-frontend-is-running-actual-software-release
+TestReplicateSlave-2/etc/promise/caddy_cached
+TestReplicateSlave-2/etc/promise/caddy_frontend_ipv4_http
+TestReplicateSlave-2/etc/promise/caddy_frontend_ipv4_https
+TestReplicateSlave-2/etc/promise/caddy_frontend_ipv6_http
+TestReplicateSlave-2/etc/promise/caddy_frontend_ipv6_https
+TestReplicateSlave-2/etc/promise/caddy_ssl_cached
+TestReplicateSlave-2/etc/promise/check-free-disk-space
+TestReplicateSlave-2/etc/promise/frontend-caddy-configuration-promise
+TestReplicateSlave-2/etc/promise/monitor-http-frontend
+TestReplicateSlave-2/etc/promise/monitor-httpd-listening-on-tcp
+TestReplicateSlave-2/etc/promise/nginx-configuration-promise
+TestReplicateSlave-2/etc/promise/nginx_frontend_ipv4_http
+TestReplicateSlave-2/etc/promise/nginx_frontend_ipv4_https
+TestReplicateSlave-2/etc/promise/nginx_frontend_ipv6_http
+TestReplicateSlave-2/etc/promise/nginx_frontend_ipv6_https
+TestReplicateSlave-2/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestReplicateSlave-2/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestReplicateSlave-2/etc/promise/re6st-connectivity
+TestReplicateSlave-2/etc/promise/trafficserver-cache-availability
+TestReplicateSlave-2/etc/promise/trafficserver-port-listening
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestReplicateSlave.test_supervisor_state-APACHE.txt

+TestReplicateSlave-0:bootstrap-monitor EXITED
+TestReplicateSlave-0:certificate_authority-on-watch RUNNING
+TestReplicateSlave-0:crond RUNNING
+TestReplicateSlave-0:monitor-httpd-graceful EXITED
+TestReplicateSlave-0:monitor-httpd-on-watch RUNNING
+TestReplicateSlave-1:bootstrap-monitor EXITED
+TestReplicateSlave-1:certificate_authority-on-watch RUNNING
+TestReplicateSlave-1:crond-on-watch RUNNING
+TestReplicateSlave-1:frontend-apache-safe-graceful EXITED
+TestReplicateSlave-1:frontend-nginx-safe-graceful EXITED
+TestReplicateSlave-1:frontend_apache-on-watch RUNNING
+TestReplicateSlave-1:frontend_nginx-on-watch RUNNING
+TestReplicateSlave-1:monitor-httpd-graceful EXITED
+TestReplicateSlave-1:monitor-httpd-on-watch RUNNING
+TestReplicateSlave-1:trafficserver-on-watch RUNNING
+TestReplicateSlave-1:trafficserver-reload EXITED
+TestReplicateSlave-2:bootstrap-monitor STOPPED
+TestReplicateSlave-2:certificate_authority-on-watch STOPPED
+TestReplicateSlave-2:crond-on-watch STOPPED
+TestReplicateSlave-2:frontend-apache-safe-graceful STOPPED
+TestReplicateSlave-2:frontend-nginx-safe-graceful STOPPED
+TestReplicateSlave-2:frontend_apache-on-watch STOPPED
+TestReplicateSlave-2:frontend_nginx-on-watch STOPPED
+TestReplicateSlave-2:monitor-httpd-graceful STOPPED
+TestReplicateSlave-2:monitor-httpd-on-watch STOPPED
+TestReplicateSlave-2:trafficserver-on-watch STOPPED
+TestReplicateSlave-2:trafficserver-reload STOPPED
+watchdog:watchdog RUNNING
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestReplicateSlave.test_supervisor_state-CADDY.txt

+TestReplicateSlave-0:bootstrap-monitor EXITED
+TestReplicateSlave-0:certificate_authority-on-watch RUNNING
+TestReplicateSlave-0:crond RUNNING
+TestReplicateSlave-0:monitor-httpd-graceful EXITED
+TestReplicateSlave-0:monitor-httpd-on-watch RUNNING
+TestReplicateSlave-1:6tunnel-11080-on-watch RUNNING
+TestReplicateSlave-1:6tunnel-11443-on-watch RUNNING
+TestReplicateSlave-1:6tunnel-12080-on-watch RUNNING
+TestReplicateSlave-1:6tunnel-12443-on-watch RUNNING
+TestReplicateSlave-1:6tunnel-26011-on-watch RUNNING
+TestReplicateSlave-1:6tunnel-26012-on-watch RUNNING
+TestReplicateSlave-1:bootstrap-monitor EXITED
+TestReplicateSlave-1:certificate_authority-on-watch RUNNING
+TestReplicateSlave-1:crond-on-watch RUNNING
+TestReplicateSlave-1:frontend-caddy-safe-graceful EXITED
+TestReplicateSlave-1:frontend-nginx-safe-graceful EXITED
+TestReplicateSlave-1:frontend_caddy-on-watch RUNNING
+TestReplicateSlave-1:frontend_nginx-on-watch RUNNING
+TestReplicateSlave-1:monitor-httpd-graceful EXITED
+TestReplicateSlave-1:monitor-httpd-on-watch RUNNING
+TestReplicateSlave-1:trafficserver-on-watch RUNNING
+TestReplicateSlave-1:trafficserver-reload EXITED
+TestReplicateSlave-2:6tunnel-11080-on-watch STOPPED
+TestReplicateSlave-2:6tunnel-11443-on-watch STOPPED
+TestReplicateSlave-2:6tunnel-12080-on-watch STOPPED
+TestReplicateSlave-2:6tunnel-12443-on-watch STOPPED
+TestReplicateSlave-2:6tunnel-26011-on-watch STOPPED
+TestReplicateSlave-2:6tunnel-26012-on-watch STOPPED
+TestReplicateSlave-2:bootstrap-monitor STOPPED
+TestReplicateSlave-2:certificate_authority-on-watch STOPPED
+TestReplicateSlave-2:crond-on-watch STOPPED
+TestReplicateSlave-2:frontend-caddy-safe-graceful STOPPED
+TestReplicateSlave-2:frontend-nginx-safe-graceful STOPPED
+TestReplicateSlave-2:frontend_caddy-on-watch STOPPED
+TestReplicateSlave-2:frontend_nginx-on-watch STOPPED
+TestReplicateSlave-2:monitor-httpd-graceful STOPPED
+TestReplicateSlave-2:monitor-httpd-on-watch STOPPED
+TestReplicateSlave-2:trafficserver-on-watch STOPPED
+TestReplicateSlave-2:trafficserver-reload STOPPED
+watchdog:watchdog RUNNING
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestSlave.test_monitor_promise_list-APACHE.txt

+TestSlave-1/etc/monitor-promise/check-_apache_custom_http_s-accepted-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_apache_custom_http_s-accepted-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_custom_domain-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_custom_domain-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_custom_domain_ssl_crt_ssl_key-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_custom_domain_ssl_crt_ssl_key-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_disabled-cookie-list-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_disabled-cookie-list-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_empty-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_empty-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_enable-http2-default-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_enable-http2-default-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_enable-http2-false-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_enable-http2-false-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_enable_cache-disable-no-cache-request-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_enable_cache-disable-no-cache-request-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_enable_cache-disable-via-header-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_enable_cache-disable-via-header-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_enable_cache-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_enable_cache-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_https-only-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_https-only-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_monitor-ipv4-test-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_monitor-ipv4-test-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_monitor-ipv4-test-ipv4-packet-list-test
+TestSlave-1/etc/monitor-promise/check-_monitor-ipv6-test-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_monitor-ipv6-test-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_monitor-ipv6-test-ipv6-packet-list-test
+TestSlave-1/etc/monitor-promise/check-_prefer-gzip-encoding-to-backend-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_prefer-gzip-encoding-to-backend-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_re6st-optimal-test-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_re6st-optimal-test-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_re6st-optimal-test-re6st-optimal-test
+TestSlave-1/etc/monitor-promise/check-_server-alias-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_server-alias-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-eventsource-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-eventsource-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-notebook-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-notebook-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-redirect-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-redirect-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-zope-default-path-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-zope-default-path-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-zope-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-zope-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-zope-path-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-zope-path-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-zope-virtualhostroot-http-port-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-zope-virtualhostroot-http-port-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-zope-virtualhostroot-https-port-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-zope-virtualhostroot-https-port-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_url-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_url-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_url_https-url-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_url_https-url-error-log-last-hour
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestSlave.test_monitor_promise_list-CADDY.txt

+TestSlave-1/etc/monitor-promise/check-_apache_custom_http_s-accepted-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_apache_custom_http_s-accepted-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_custom_domain-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_custom_domain-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_custom_domain_ssl_crt_ssl_key-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_custom_domain_ssl_crt_ssl_key-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_disabled-cookie-list-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_disabled-cookie-list-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_empty-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_empty-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_enable-http2-default-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_enable-http2-default-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_enable-http2-false-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_enable-http2-false-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_enable_cache-disable-no-cache-request-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_enable_cache-disable-no-cache-request-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_enable_cache-disable-via-header-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_enable_cache-disable-via-header-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_enable_cache-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_enable_cache-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_https-only-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_https-only-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_monitor-ipv4-test-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_monitor-ipv4-test-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_monitor-ipv4-test-ipv4-packet-list-test
+TestSlave-1/etc/monitor-promise/check-_monitor-ipv6-test-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_monitor-ipv6-test-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_monitor-ipv6-test-ipv6-packet-list-test
+TestSlave-1/etc/monitor-promise/check-_prefer-gzip-encoding-to-backend-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_prefer-gzip-encoding-to-backend-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_re6st-optimal-test-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_re6st-optimal-test-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_re6st-optimal-test-re6st-optimal-test
+TestSlave-1/etc/monitor-promise/check-_server-alias-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_server-alias-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-eventsource-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-eventsource-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-notebook-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-notebook-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-redirect-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-redirect-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-zope-default-path-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-zope-default-path-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-zope-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-zope-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-zope-path-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-zope-path-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-zope-virtualhostroot-http-port-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-zope-virtualhostroot-http-port-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_type-zope-virtualhostroot-https-port-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_type-zope-virtualhostroot-https-port-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_url-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_url-error-log-last-hour
+TestSlave-1/etc/monitor-promise/check-_url_https-url-error-log-last-day
+TestSlave-1/etc/monitor-promise/check-_url_https-url-error-log-last-hour
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestSlave.test_promise_list-APACHE.txt

+TestSlave-0/etc/promise/check-free-disk-space
+TestSlave-0/etc/promise/monitor-http-frontend
+TestSlave-0/etc/promise/monitor-httpd-listening-on-tcp
+TestSlave-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestSlave-1/etc/promise/apache-frontend-is-running-actual-software-release
+TestSlave-1/etc/promise/apache-mpm-watchdog
+TestSlave-1/etc/promise/apache_cached
+TestSlave-1/etc/promise/apache_frontend_ipv4_http
+TestSlave-1/etc/promise/apache_frontend_ipv4_https
+TestSlave-1/etc/promise/apache_frontend_ipv6_http
+TestSlave-1/etc/promise/apache_frontend_ipv6_https
+TestSlave-1/etc/promise/apache_ssl_cached
+TestSlave-1/etc/promise/check-free-disk-space
+TestSlave-1/etc/promise/frontend-apache-configuration-promise
+TestSlave-1/etc/promise/monitor-http-frontend
+TestSlave-1/etc/promise/monitor-httpd-listening-on-tcp
+TestSlave-1/etc/promise/nginx-configuration-promise
+TestSlave-1/etc/promise/nginx_frontend_ipv4_http
+TestSlave-1/etc/promise/nginx_frontend_ipv4_https
+TestSlave-1/etc/promise/nginx_frontend_ipv6_http
+TestSlave-1/etc/promise/nginx_frontend_ipv6_https
+TestSlave-1/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestSlave-1/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestSlave-1/etc/promise/re6st-connectivity
+TestSlave-1/etc/promise/trafficserver-cache-availability
+TestSlave-1/etc/promise/trafficserver-port-listening
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestSlave.test_promise_list-CADDY.txt

+TestSlave-0/etc/promise/check-free-disk-space
+TestSlave-0/etc/promise/monitor-http-frontend
+TestSlave-0/etc/promise/monitor-httpd-listening-on-tcp
+TestSlave-0/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestSlave-1/etc/promise/caddy-frontend-is-running-actual-software-release
+TestSlave-1/etc/promise/caddy_cached
+TestSlave-1/etc/promise/caddy_frontend_ipv4_http
+TestSlave-1/etc/promise/caddy_frontend_ipv4_https
+TestSlave-1/etc/promise/caddy_frontend_ipv6_http
+TestSlave-1/etc/promise/caddy_frontend_ipv6_https
+TestSlave-1/etc/promise/caddy_ssl_cached
+TestSlave-1/etc/promise/check-free-disk-space
+TestSlave-1/etc/promise/frontend-caddy-configuration-promise
+TestSlave-1/etc/promise/monitor-http-frontend
+TestSlave-1/etc/promise/monitor-httpd-listening-on-tcp
+TestSlave-1/etc/promise/nginx-configuration-promise
+TestSlave-1/etc/promise/nginx_frontend_ipv4_http
+TestSlave-1/etc/promise/nginx_frontend_ipv4_https
+TestSlave-1/etc/promise/nginx_frontend_ipv6_http
+TestSlave-1/etc/promise/nginx_frontend_ipv6_https
+TestSlave-1/etc/promise/promise-monitor-httpd-is-process-older-than-dependency-set
+TestSlave-1/etc/promise/promise-nginx-is-process-older-than-dependency-set
+TestSlave-1/etc/promise/re6st-connectivity
+TestSlave-1/etc/promise/trafficserver-cache-availability
+TestSlave-1/etc/promise/trafficserver-port-listening
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestSlave.test_supervisor_state-APACHE.txt

+TestSlave-0:bootstrap-monitor EXITED
+TestSlave-0:certificate_authority-on-watch RUNNING
+TestSlave-0:crond RUNNING
+TestSlave-0:monitor-httpd-graceful EXITED
+TestSlave-0:monitor-httpd-on-watch RUNNING
+TestSlave-1:bootstrap-monitor EXITED
+TestSlave-1:certificate_authority-on-watch RUNNING
+TestSlave-1:crond-on-watch RUNNING
+TestSlave-1:frontend-apache-safe-graceful EXITED
+TestSlave-1:frontend-nginx-safe-graceful EXITED
+TestSlave-1:frontend_apache-on-watch RUNNING
+TestSlave-1:frontend_nginx-on-watch RUNNING
+TestSlave-1:monitor-httpd-graceful EXITED
+TestSlave-1:monitor-httpd-on-watch RUNNING
+TestSlave-1:trafficserver-on-watch RUNNING
+TestSlave-1:trafficserver-reload EXITED
+watchdog:watchdog RUNNING
\ No newline at end of file

software/caddy-frontend/test/test_data/test.TestSlave.test_supervisor_state-CADDY.txt

+TestSlave-0:bootstrap-monitor EXITED
+TestSlave-0:certificate_authority-on-watch RUNNING
+TestSlave-0:crond RUNNING
+TestSlave-0:monitor-httpd-graceful EXITED
+TestSlave-0:monitor-httpd-on-watch RUNNING
+TestSlave-1:6tunnel-11080-on-watch RUNNING
+TestSlave-1:6tunnel-11443-on-watch RUNNING
+TestSlave-1:6tunnel-12080-on-watch RUNNING
+TestSlave-1:6tunnel-12443-on-watch RUNNING
+TestSlave-1:6tunnel-26011-on-watch RUNNING
+TestSlave-1:6tunnel-26012-on-watch RUNNING
+TestSlave-1:bootstrap-monitor EXITED
+TestSlave-1:certificate_authority-on-watch RUNNING
+TestSlave-1:crond-on-watch RUNNING
+TestSlave-1:frontend-caddy-safe-graceful EXITED
+TestSlave-1:frontend-nginx-safe-graceful EXITED
+TestSlave-1:frontend_caddy-on-watch RUNNING
+TestSlave-1:frontend_nginx-on-watch RUNNING
+TestSlave-1:monitor-httpd-graceful EXITED
+TestSlave-1:monitor-httpd-on-watch RUNNING
+TestSlave-1:trafficserver-on-watch RUNNING
+TestSlave-1:trafficserver-reload EXITED
+watchdog:watchdog RUNNING
\ No newline at end of file

software/caddy-frontend/test/utils.py

@@ -46,19 +46,6 @@ LOCAL_IPV4 = os.environ['LOCAL_IPV4']
 GLOBAL_IPV6 = os.environ['GLOBAL_IPV6']
 
 
-def isHTTP2(domain, ip):
-  curl_command = '%(curl)s --http2 -v -k -H "Host: %(domain)s" ' \
-    'https://%(domain)s:4443/ --resolve %(domain)s:4443:%(ip)s' % dict(
-      ip=ip, domain=domain, curl=os.environ['CURL'])
-  prc = subprocess.Popen(
-    curl_command.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE
-  )
-  out, err = prc.communicate()
-  assert prc.returncode == 0, "Problem running %r. Output:\n%s\nError:\n%s" % (
-    curl_command, out, err)
-  return 'Using HTTP2, server supports multi-use' in err
-
-
 def der2pem(der):
   certificate, error = subprocess.Popen(
       'openssl x509 -inform der'.split(), stdin=subprocess.PIPE,

software/caddy-frontend/test/wildcard.example.com.crt

+-----BEGIN CERTIFICATE-----
+MIIDjzCCAnegAwIBAgIJAP4QzV9d5d8KMA0GCSqGSIb3DQEBCwUAMF0xCzAJBgNV
+BAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBX
+aWRnaXRzIFB0eSBMdGQxFjAUBgNVBAMMDSouZXhhbXBsZS5jb20wIBcNMTgwNDE3
+MTE0MjAxWhgPMjExODAzMjQxMTQyMDFaMF0xCzAJBgNVBAYTAkFVMRMwEQYDVQQI
+DApTb21lLVN0YXRlMSEwHwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQx
+FjAUBgNVBAMMDSouZXhhbXBsZS5jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
+ggEKAoIBAQC0MNnojTq6Yp60ecvP5lZGa6owZp64sumaT66JInTFJcSV/ls0AbPN
+KPTcNRgbFLIuv/3Xhgi6YAxIz2PXdCDPj1fp4rVIijhpedaWZaIOeTqSGEg+5/iL
+4UTxm166NgCU1zp0QsmU8MXJFv4YxTZsF9LlGFcP6uUQ9sY98yv+hErCxRXo+dXd
+GGG4LTVLGPeRYNX2JVD5BxoNkL5/3IMylrFvI8aRFTKVn1P8UPJ5K9du3E0wHJY6
+MkstZX3xKcGKSn2w1zIaq/NcrbLXvp6eZauLtMpZ9vW+CtYV3diOm2TiMvQIyCRM
+4mWbaf76bpGiz9/+11w6U9n6zMzKTq+5AgMBAAGjUDBOMB0GA1UdDgQWBBT/Kswu
+BKM3GXaIWvQ8Vs1xhs/1vzAfBgNVHSMEGDAWgBT/KswuBKM3GXaIWvQ8Vs1xhs/1
+vzAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQAeeV7VIqbNL6Xe0I5y
+fl44ogBY0zoYJH+p7HCebazZKepy7f+EeWv8B3dHODrilSYCnsOqhta8mMSMrgsT
+TFByr/8NN/4UFe9FeKnxD9Sun0EetESkaeMqAGCK921lT0eU4IhA0JLRj16HomuK
+I/JBFwUXFn6vVypw5R41zwnikv+EB0fSC4biSXWXUarGqlRCF7o00CPKqAaTE0yX
+H4Yz3lR/Vuce7uFvkIY+F4vXtq1sy/tb4QBWlDS6t7cmeBGcvaQ8mlndA9T+us0l
+/wb9mzdTcwkrkM2kk++GnS0NCAQfOalF3x8wG6j8DrU2dQ1NXh205c/zo0BljQr8
+P84v
+-----END CERTIFICATE-----

software/caddy-frontend/test/wildcard.example.com.key

+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC0MNnojTq6Yp60
+ecvP5lZGa6owZp64sumaT66JInTFJcSV/ls0AbPNKPTcNRgbFLIuv/3Xhgi6YAxI
+z2PXdCDPj1fp4rVIijhpedaWZaIOeTqSGEg+5/iL4UTxm166NgCU1zp0QsmU8MXJ
+Fv4YxTZsF9LlGFcP6uUQ9sY98yv+hErCxRXo+dXdGGG4LTVLGPeRYNX2JVD5BxoN
+kL5/3IMylrFvI8aRFTKVn1P8UPJ5K9du3E0wHJY6MkstZX3xKcGKSn2w1zIaq/Nc
+rbLXvp6eZauLtMpZ9vW+CtYV3diOm2TiMvQIyCRM4mWbaf76bpGiz9/+11w6U9n6
+zMzKTq+5AgMBAAECggEAR9n2+pFearYqnMK4b9Vkb7485gH1pqbJGdxON6bCs16F
+Dl6X1ZwcK2H6idiuHRZamuO5//gVgOQN4fa41FAdSUbagowBR8S+C+kmlWA/h8/1
+eA4wuMzdQkH4sPMIie5Auxk72OJM6ZQ8+huuBQiW0/GICgxzowhCgUo18LwHvfwt
+XWLHplRFczgM4WEu+HVx1W9y/irOhEUEzwNfXdDTVE4bnwzb24qR0CRIdp3gc8Os
+JoUFMgbV3qfJLmzqURLIlVc3Y9FFbWrr5zhzTx2vvoT1j83e56qKHbKanr2R6NQZ
+UOsCgDvzrc9WqKE9/hwvxvPlx/L3UWuhPMpljZ8gBQKBgQDX4Qo27l8KPk9fXA18
+SrRcAAGN+moc+Y0T9WbcbXCJLLU6TO3eJqW9H3Kwb80O/zycUBFK/dIOwZZYgsuQ
+oXFG4ykSXFY/JGTEBIkvQ7LI/7t5mn0xlw3tqB7xuMO5QEyZMQFi0xP5h1B5coiO
+Wv9T1xit4FHX2EN/CJLwlzzl1wKBgQDVrdvGi+j/1pGaEST1yhvrDduHrlMsF4BI
+X8VaNXNXg9+GxsAA6+pRPRoHvmmz/RUr/km+JxWLHEZpFDOhIzJV4JYXv/q7KDH+
+Mjf7uyRshBnR+QU38RqkENIJhEZJSa8ZYmkgU9yCDozkfVzYKdxUy6Z0+o2Omzls
+cpZP1PFE7wKBgQCGXZx0+kMPZh8TFIGURg8iYCKXkzBu3miP7qNaOYfc6YXXRsCb
+D+UC5MsGxF+WoQjBphhNW9RduOJyLt6zI7kUzRjoQ66u2GEbnFMipvlln765fo3D
+yugxbv3rp/uylzHV+6mIMCbzneRZ4w7ZxAu9zFihCMkIFqRUMir7MrcFuwKBgFbK
+88ZF9jJU+XdXF2gu3AAx9MW77VSvhw/ets7ZfyxBCH46JKs7KEYvR291zIGrfvoL
+o/B09681oPP1nLMLFNsFCnJDLJjwzr2tsEez0CuzzLkZKSF78ZJKssXi0JncMB9j
+dcgHyD2bo2b79MZo2nIm9kn1q6INMtn2AVAT8pxJAoGAZfysuUMc0bdKVi41SD0A
+Ej7qX+qbXX+aA4OkTqJP3QxssD6CuZZwUKW7qj8AoOcLKsmwdjetetny46OMEXzN
+5Fk3ahCD1cycFGBawNY10x5Xy+4iApzPiO1Ujd3t7FAIrLPWFwzmLIL8pxUNuHEn
+OC9RrI4tzsvWHhMaLKVCh0g=
+-----END PRIVATE KEY-----