Skip to content

slapos
slapos
Commit 7ae4d31a authored by Łukasz Nowak's avatar Łukasz Nowak
Browse files
Options

Merge branch 'feature/edgetest-pop' 

Edggetest monitoring got capability of region definition in each cluster.

In order to stabilise parameter serialisation the json-in-xml has been used.
parents cfe9f936 e62fe778
Pipeline #15416 failed with stage
    in 0 seconds
    Hide whitespace changes
    Inline Side-by-side
    Showing with 1334 additions and 671 deletions
    software/monitor/buildout.hash.cfg
    View file @ 7ae4d31a
    ......@@ -14,7 +14,7 @@
    # not need these here).
    [template]
    filename = instance.cfg
    md5sum = 9ddae686379e8d747410c1adf82b47d6
    md5sum = c115ed9d4ff0f785d79cdcacbb0bd1ad
    [template-monitor]
    _update_hash_filename_ = instance-monitor.cfg.jinja2
    ......@@ -26,11 +26,11 @@ md5sum = 2eb5596544d9c341acf653d4f7ce2680
    [template-monitor-edgetest]
    _update_hash_filename_ = instance-monitor-edgetest.cfg.jinja2
    md5sum = a57106ee88ff3295b9ffce84105da79b
    md5sum = 3c8ab4e78f66c974eb95afc595a13514
    [template-monitor-edgebot]
    _update_hash_filename_ = instance-monitor-edgebot.cfg.jinja2
    md5sum = c1885a42aadd45bab3185a53258d4ff4
    md5sum = 365a6cc6831267a73fa5ebd56ad394ee
    [network-bench-cfg]
    filename = network_bench.cfg.in
    ......@@ -42,4 +42,4 @@ md5sum = d3cfa1f6760e3fa64ccd64acf213bdfb
    [template-surykatka-ini]
    _update_hash_filename_ = surykatka.ini.jinja2
    md5sum = 89545501f0e5bf11608978886429da3d
    md5sum = 609c6cca763b73a80fa05ee56475eb20
    software/monitor/instance-edgetest-input-schema.json
    View file @ 7ae4d31a
    {
    "$schema": "http://json-schema.org/draft-04/schema#",
    "type": "object",
    "properties": {
    "nameserver": {
    "default": "",
    "title": "Nameserver",
    "description": "Space separated list of name servers to use.",
    "type": "string"
    },
    "check-status-code": {
    "default": "200",
    "title": "Default Check HTTP Code",
    "description": "Default HTTP code to check against (default: 200).",
    "type": "string"
    },
    "check-http-header-dict": {
    "default": "{}",
    "title": "HTTP header dict to check",
    "description": "JSON dict of expected HTTP header, like {\"Cache-Control\": \"max-age=3600, public\", \"Vary\": \"Accept-Encoding\"}",
    "region-dict": {
    "title": "Regions",
    "description": "Defines regions of the cluster",
    "patternProperties": {
    ".*": {
    "properties": {
    "state": {
    "title": "State",
    "description": "State of the node of the region. Can be used to destroy not needed regions.",
    "type": "string",
    "default": "started",
    "enum": [
    "started",
    "stopped",
    "destroyed"
    ]
    },
    "sla-computer_guid": {
    "title": "GUID of the computer on which this region shall be deployed",
    "description": "Unique identifier of the computer, like \"COMP-1234\". By default, let Master choose a computer.",
    "type": "string",
    "default": ""
    },
    "nameserver-list": {
    "default": [],
    "title": "Nameservers",
    "description": "List of nameservers to use.",
    "type": "array"
    },
    "check-frontend-ip-list": {
    "default": [],
    "title": "Default Frontend IPs to check",
    "description": "List of default frontend IPs to check, if empty no constraint is used.",
    "type": "array"
    }
    },
    "type": "object"
    }
    },
    "type": "object"
    },
    "check-frontend-ip": {
    "default": "",
    "title": "Default space separated list of Frontend IPs to check",
    "description": "Default list of Frontend IPs to check, if empty no constraint is used.",
    "type": "string"
    },
    "check-certificate-expiration-days": {
    "default": "15",
    "title": "Default certificate expiration days check",
    "description": "Default amount of days to consider certificate as being to-be-expired (default: 15).",
    "type": "string"
    },
    "check-maximum-elapsed-time": {
    "default": "2",
    "title": "Default maximum elapsed time for a site to reply (seconds)",
    "description": "Default maximum elapsed time for a site to reply to be considered good (default: 2s).",
    "type": "string"
    "nameserver-list": {
    "default": [],
    "title": "Nameservers (backward compatibility)",
    "description": "List of nameservers to use. Note: This is backward compatibility, use region-dict for full configuration control.",
    "type": "array"
    },
    "failure-amount": {
    "default": "1",
    "title": "Default amount of failures to consider URL as in bad state",
    "description": "Default amount of failures to consider URL as in bad state, can be set to higher value for endpoints with accepted short outages (default: 1).",
    "type": "string"
    "check-frontend-ip-list": {
    "default": [],
    "title": "Default Frontend IPs to check (backward compatibility)",
    "description": "List of default frontend IPs to check, if empty no constraint is used. Note: This is backward compatibility, use region-dict for full configuration control.",
    "type": "array"
    }
    }
    }
    software/monitor/instance-edgetest-slave-input-schema.json
    View file @ 7ae4d31a
    {
    "$schema": "http://json-schema.org/draft-04/schema#",
    "type": "object",
    "properties": {
    "url": {
    "title": "URL to check",
    "description": "URL to check, like https://example.com",
    "description": "URL to check, like https://example.com/",
    "type": "string"
    },
    "check-status-code": {
    "default": "Master default",
    "title": "Default Check HTTP Code.",
    "description": "HTTP code to check against (default: comes from master partition).",
    "type": "string"
    },
    "check-http-header-dict": {
    "default": "Master default",
    "title": "HTTP header dict to check",
    "description": "JSON dict of expected HTTP header, like {\"Cache-Control\": \"max-age=3600, public\", \"Vary\": \"Accept-Encoding\"}",
    "type": "object"
    "region-dict": {
    "title": "Applicable Regions",
    "description": "Puts the check on the defined regions. No definition will result with presence in all regions.",
    "patternProperties": {
    ".*": {
    "properties": {
    "state": {
    "title": "State",
    "description": "State of the check of the region. Used only to make it correctly visible in the SlapOS Master UI if no other parameters are defined.",
    "type": "string",
    "default": "present",
    "enum": [
    "present"
    ]
    },
    "check-frontend-ip-list": {
    "default": [],
    "title": "Frontend IPs to check",
    "description": "List of default frontend IPs to check, if empty no constraint is used. Defaults to region configuration.",
    "type": "array"
    }
    },
    "type": "object"
    }
    },
    "type": "object",
    "default": {}
    },
    "check-frontend-ip": {
    "default": "Master default",
    "title": "Space separated list of Frontend IPs to check",
    "description": "List of Frontend IPs to check, if empty no constraint is used (default: comes from master partition).",
    "type": "string"
    "check-status-code": {
    "title": "HTTP Code Check",
    "description": "Expected response HTTP Code.",
    "type": "number",
    "default": 200,
    "minimum": 100,
    "maximum": 599
    },
    "check-certificate-expiration-days": {
    "default": "Master default",
    "title": "Certificate expiration days check",
    "description": "Amount of days to consider certificate as being to-be-expired (default: comes from master partition).",
    "type": "string"
    "title": "Certificate Expiration Check (days)",
    "description": "Amount of days to consider certificate as being to-be-expired.",
    "type": "number",
    "default": 15,
    "minimum": 1
    },
    "check-maximum-elapsed-time": {
    "default": "Master default",
    "title": "Maximum elapsed time for a site to reply (seconds)",
    "description": "Maximum elapsed time for a site to reply to be considered good.(default: comes from master partition).",
    "type": "string"
    "title": "Maximum Elapsed Check (seconds)",
    "description": "Maximum elapsed time for a site to reply to be considered good.",
    "type": "number",
    "default": 2,
    "minimum": 1
    },
    "check-http-header-dict": {
    "title": "HTTP Header Check",
    "description": "JSON object of expected HTTP header, like {\"Cache-Control\": \"max-age=3600, public\", \"Vary\": \"Accept-Encoding\"}. Note: Shall be expressed directly as object, without any additional qouting.",
    "type": "object",
    "default": {}
    },
    "failure-amount": {
    "default": "Master default",
    "title": "Amount of failures to consider URL as in bad state",
    "description": "Amount of failures to consider URL as in bad state, can be set to higher value for endpoints with accepted short outages (default: comes from master partition).",
    "type": "string"
    "title": "Failure Amount",
    "description": "Amount of failures to consider URL as in bad state, can be set to higher value for endpoints with accepted short outages.",
    "type": "number",
    "default": 2,
    "minimum": 1
    },
    "check-frontend-ip-list": {
    "title": "Frontend IPs to check (backward compatibility)",
    "description": "List of Frontend IPs to check, if empty no constraint is used. Defaults to region configuration. Note: Use region-dict's check-frontend-ip-list to ensure specific check on each region.",
    "type": "array"
    }
    }
    }
    software/monitor/instance-monitor-edgebot.cfg.jinja2
    View file @ 7ae4d31a
    ......@@ -9,39 +9,27 @@
    {%- set extra_slave_instance_list = slapparameter_dict.get('extra_slave_instance_list') %}
    {%- if extra_slave_instance_list %}
    {#- Create slaves to process with setting up defaults #}
    {%- for slave in json_module.loads(extra_slave_instance_list) | sort(attribute='slave_title') %}
    {%- if 'check-status-code' not in slave %}
    {%- do slave.__setitem__('check-status-code', CONFIGURATION['check-status-code']) %}
    {%- endif %}
    {%- if 'check-http-header-dict' not in slave %}
    {%- do slave.__setitem__('check-http-header-dict', CONFIGURATION['check-http-header-dict']) %}
    {%- endif %}
    {%- if 'check-certificate-expiration-days' not in slave %}
    {%- do slave.__setitem__('check-certificate-expiration-days', CONFIGURATION['check-certificate-expiration-days']) %}
    {%- endif %}
    {%- if 'failure-amount' not in slave %}
    {%- do slave.__setitem__('failure-amount', CONFIGURATION['failure-amount']) %}
    {%- endif %}
    {%- if 'check-maximum-elapsed-time' not in slave %}
    {%- do slave.__setitem__('check-maximum-elapsed-time', CONFIGURATION['check-maximum-elapsed-time']) %}
    {%- endif %}
    {%- if 'check-frontend-ip' not in slave %}
    {%- do slave.__setitem__('check-frontend-ip', CONFIGURATION['check-frontend-ip']) %}
    {%- endif %}
    {%- if 'url' in slave %}
    {%- set class = slave['check-maximum-elapsed-time'] %}
    {%- if class not in slave_instance_dict %}
    {%- do slave_instance_dict.__setitem__(class, []) %}
    {%- for slave in extra_slave_instance_list | sort(attribute='-slave-title') %}
    {%- do slave.setdefault('check-status-code', 200) %}
    {%- do slave.setdefault('check-http-header-dict', {}) %}
    {%- do slave.setdefault('check-certificate-expiration-days', 15) %}
    {%- do slave.setdefault('failure-amount', 2) %}
    {%- do slave.setdefault('check-maximum-elapsed-time', 2) %}
    {%- do slave.setdefault('check-frontend-ip-list', CONFIGURATION['check-frontend-ip-list']) %}
    {%- if 'url' in slave %}
    {%- set class = slave['check-maximum-elapsed-time'] %}
    {%- if class not in slave_instance_dict %}
    {%- do slave_instance_dict.__setitem__(class, []) %}
    {%- endif %}
    {%- do slave_instance_dict[class].append(slave) %}
    {%- endif %}
    {%- do slave_instance_dict[class].append(slave) %}
    {%- endif %}
    {%- endfor %}
    {%- endif %}
    {%- set part_list = [] %}
    {%- for class, slave_instance_list in slave_instance_dict.items() %}
    {#- class is used to separate surykatka with different timeouts #}
    {%- for slave in slave_instance_list | sort(attribute='slave_title') %}
    {%- set part_id = 'http-query-' ~ slave['slave_reference'] ~ '-promise' %}
    {%- for slave in slave_instance_list | sort(attribute='-slave-title') %}
    {%- set part_id = 'http-query-' ~ hashlib_module.md5(slave['-slave-reference'].encode('utf-8')).hexdigest() ~ '-promise' %}
    {%- do part_list.append(part_id) %}
    {%- set safe_name = part_id.replace('_', '').replace('.', '-').replace(' ', '-') %}
    [{{part_id}}]
    ......@@ -51,11 +39,11 @@ name = {{ safe_name }}.py
    config-report = http_query
    config-url = {{ slave['url'] }}
    config-status-code = {{ slave['check-status-code'] }}
    config-http-header-dict = {{ slave['check-http-header-dict'] }}
    config-http-header-dict = {{ json_module.dumps(slave['check-http-header-dict']) }}
    config-certificate-expiration-days = {{ slave['check-certificate-expiration-days'] }}
    config-failure-amount = {{ slave['failure-amount'] }}
    config-maximum-elapsed-time = {{ slave['check-maximum-elapsed-time'] }}
    config-ip-list = {{ slave['check-frontend-ip'] }}
    config-ip-list = {{ ' '.join(slave['check-frontend-ip-list']) }}
    config-json-file = ${surykatka-config-{{ class }}:json}
    {%- endfor %}
    ......@@ -72,7 +60,7 @@ db = ${directory:srv}/surykatka-{{ class }}.db
    rendered = ${directory:etc}/surykatka-{{ class }}.ini
    template = {{ template_surykatka_ini }}
    slave_instance_list = {{ dumps(slave_instance_list) }}
    nameserver = {{ dumps(CONFIGURATION['nameserver']) }}
    nameserver_list = {{ dumps(CONFIGURATION['nameserver-list']) }}
    json = ${directory:srv}/surykatka-{{ class }}.json
    {#- timeout is just a bit bigger than class time #}
    timeout = {{ int(class) + 2 }}
    ......@@ -80,7 +68,7 @@ timeout = {{ int(class) + 2 }}
    context =
    import json_module json
    key db :db
    key nameserver :nameserver
    key nameserver_list :nameserver_list
    key slave_instance_list :slave_instance_list
    key timeout :timeout
    ......@@ -110,9 +98,9 @@ cron-entries = ${directory:etc}/cron.d
    name = surykatka-status-{{ class }}
    frequency = */2 * * * *
    command = ${surykatka-status-json-{{ class }}:rendered}
    {%- do part_list.append('surykatka-' + class) %}
    {%- do part_list.append('surykatka-bot-promise-' + class) %}
    {%- do part_list.append('cron-entry-surykatka-status-' + class) %}
    {%- do part_list.append('surykatka-%i'% (class,)) %}
    {%- do part_list.append('surykatka-bot-promise-%i' % (class,)) %}
    {%- do part_list.append('cron-entry-surykatka-status-%i' % (class,)) %}
    {%- endfor %}
    [buildout]
    ......@@ -163,4 +151,4 @@ key = ${slap-connection:key-file}
    cert = ${slap-connection:cert-file}
    [slap-parameter]
    {%- endif %}
    {%- endif %} {#- if slap_software_type == software_type #}
    software/monitor/instance-monitor-edgetest.cfg.jinja2
    View file @ 7ae4d31a
    ......@@ -16,34 +16,86 @@ extensions = jinja2.ext.do
    extra-context =
    section slave_information slap-configuration
    {% set part_list = [] -%}
    # Publish information for each slave
    {% set part_list = [] -%}
    {%- set edgebot_software_type = 'edgebot' %}
    {%- set edgebot_quantity = slapparameter_dict.pop('edgebot-quantity', '1') | int %}
    {%- set edgebot_list = [] %}
    {%- set edgebot_section_list = [] %}
    {%- set slave_list_name = 'extra_slave_instance_list' %}
    {%- set request_dict = {} %}
    {%- set namebase = "edgebot" %}
    {%- set authorized_slave_list = [] %}
    {%- set monitor_base_url_dict = {} -%}
    {%- if 'region-dict' not in slapparameter_dict %}
    {#- Be nice and allow to work with default configuration #}
    {%- do slapparameter_dict.__setitem__('region-dict', {
    '1': {
    'sla-computer_guid': slap_configuration['computer'],
    'state': slap_configuration['instance-state'],
    'nameserver-list': slapparameter_dict.get('nameserver-list', []),
    'check-frontend-ip-list': slapparameter_dict.get('check-frontend-ip-list', []),
    }
    }) %}
    {%- endif %}
    {%- set active_region_list = [] %}
    {%- for region_name in sorted(slapparameter_dict['region-dict']) %}
    {%- set region_parameter_dict = slapparameter_dict['region-dict'][region_name] %}
    {%- if region_parameter_dict.get('state', 'started') == 'started' %}
    {%- do active_region_list.append(region_name) %}
    {%- endif %}
    {%- endfor %}
    {%- set authorized_slave_dict = {} %}
    {%- set publish_slave_dict_dict = {} %}
    {%- for slave in slave_instance_list | sort(attribute='slave_title') %}
    {%- do authorized_slave_list.append(slave) %}
    {%- set slave_reference = slave.pop('slave_reference') %}
    {%- set publish_dict = {'assigned-region-dict': {}} %}
    {%- if '_' in slave %}
    {%- set base_slave_dict = json_module.loads(slave.pop('_')) %} {#- XXX: Unsafe! #}
    {%- do base_slave_dict.__setitem__('-slave-title', slave['slave_title']) %}
    {%- do base_slave_dict.__setitem__('-slave-reference', slave_reference) %}
    {%- set slave_region_dict = base_slave_dict.pop('region-dict', {}) %}
    {%- if slave_region_dict == {} %}
    {%- for region in active_region_list %}
    {%- do slave_region_dict.__setitem__(region, {}) %}
    {%- endfor %}
    {%- endif %}
    {%- for region in slave_region_dict %}
    {%- if region in active_region_list %}
    {%- set region_info = {
    'nameserver-list': slapparameter_dict['region-dict'][region].get('nameserver-list') or slapparameter_dict.get('slapparameter_dict') or [],
    'check-frontend-ip-list': slave_region_dict[region].get('check-frontend-ip-list') or base_slave_dict.get('check-frontend-ip-list') or slapparameter_dict['region-dict'][region].get('check-frontend-ip-list') or slapparameter_dict.get('check-frontend-ip-list') or [],
    } %}
    {%- do publish_dict['assigned-region-dict'].__setitem__(region, region_info) %}
    {%- set slave_dict = base_slave_dict.copy() %}
    {%- do slave_dict.update(region_info) %}
    {%- if region not in authorized_slave_dict %}
    {%- do authorized_slave_dict.__setitem__(region, [slave_dict]) %}
    {%- else %}
    {%- do authorized_slave_dict[region].append(slave_dict) %}
    {%- endif %}
    {%- endif %}
    {%- endfor %}
    {%- endif %}
    {%- do publish_slave_dict_dict.__setitem__(slave_reference, publish_dict) %}
    {%- endfor %}
    {%- set monitor_base_port = int(slap_configuration['configuration.monitor-base-port']) %}
    {%- for i in range(1, edgebot_quantity + 1) %}
    {%- set edgebot_name = "%s-%s" % (namebase, i) %}
    {%- set request_section_title = 'request-%s' % edgebot_name %}
    {%- do edgebot_list.append(edgebot_name) %}
    {%- do edgebot_section_list.append(request_section_title) %}
    {%- set number = {'i': 1} %}
    {%- for region_name in sorted(slapparameter_dict['region-dict']) %}
    {%- set region_parameter_dict = slapparameter_dict['region-dict'][region_name] %}
    {%- set edgebot_name = "%s-%s" % (namebase, region_name) %}
    {%- set request_section_title = 'request-%s' % (hashlib_module.md5(edgebot_name.encode('utf-8')).hexdigest(),) %}
    {%- do part_list.append(request_section_title) %}
    {%- do request_dict.__setitem__(request_section_title,
    {
    'config': {'monitor-httpd-port': monitor_base_port + i},
    'name': edgebot_name,
    'sla': {},
    'state': 'started',
    }) %}
    {#- Note: monitor-httpd-port will vary on regions being added and removed,
    but this is accepted, as it's only internal trick #}
    {%- do request_dict.__setitem__(
    request_section_title,
    {
    'config': {
    'monitor-httpd-port': monitor_base_port + number['i'],
    'check-frontend-ip-list': region_parameter_dict.get('check-frontend-ip-list', []),
    'nameserver-list': region_parameter_dict.get('nameserver-list', []),
    'extra_slave_instance_list': authorized_slave_dict.get(region_name, [])
    },
    'name': edgebot_name,
    'sla': {'computer_guid': region_parameter_dict['sla-computer_guid']},
    'state': region_parameter_dict.get('state', 'started'),
    }) %}
    {%- do number.__setitem__('i', number['i'] + 1) %}
    {%- endfor %}
    [replicate]
    ......@@ -54,54 +106,58 @@ config-monitor-username = ${monitor-instance-parameter:username}
    config-monitor-password = ${monitor-htpasswd:passwd}
    software-url = ${slap-connection:software-release-url}
    software-type = {{edgebot_software_type}}
    return = monitor-base-url
    {% for section, edgebot_request in request_dict.items() %}
    {%- set monitor_base_url_dict = {} -%}
    {% for section, edgebot_request in request_dict.items() %}
    [{{section}}]
    <= replicate
    name = {{ edgebot_request.get('name') }}
    {%- if edgebot_request.get('state') %}
    state = {{ edgebot_request.get('state') }}
    {%- endif%}
    {%- set slave_configuration_dict = slapparameter_dict %}
    {%- do slave_configuration_dict.update(edgebot_request.get('config')) %}
    {%- do slave_configuration_dict.__setitem__(slave_list_name, json_module.dumps(authorized_slave_list)) %}
    {%- for config_key, config_value in slave_configuration_dict.items() %}
    name = {{ edgebot_request['name'] }}
    state = {{ edgebot_request['state'] }}
    {%- if edgebot_request['state'] != 'destroyed' %}
    {%- do monitor_base_url_dict.__setitem__(section, '${' ~ section ~ ':connection-monitor-base-url}') %}
    return = monitor-base-url
    {%- endif %}
    {%- set edgebot_configuration_dict = edgebot_request['config'] %}
    {%- for config_key, config_value in edgebot_configuration_dict.items() %}
    config-{{ config_key }} = {{ dumps(config_value) }}
    {% endfor -%}
    {%- if edgebot_request.get('sla') %}
    {%- for parameter, value in edgebot_request.get('sla').items() %}
    {% endfor -%}
    {%- for parameter, value in edgebot_request['sla'].items() %}
    sla-{{ parameter }} = {{ value }}
    {%- endfor %}
    {%- else %}
    # As no SLA was provided, by default it is requested on the same computer
    sla-computer_guid = ${slap-connection:computer-id}
    {% endif %}
    {%- do monitor_base_url_dict.__setitem__(section, '${' ~ section ~ ':connection-monitor-base-url}') -%}
    {%- endfor %}
    {%- endfor %}
    {%- set directory_list = [] -%}
    {%- for slave_instance in slave_instance_list -%}
    {%- set publish_section_title = 'publish-%s' % slave_instance.get('slave_reference') -%}
    # Publish information for each slave
    {%- for slave_reference, publish_dict in publish_slave_dict_dict.items() -%}
    {%- set publish_section_title = 'publish-%s' % (hashlib_module.md5(slave_reference.encode('utf-8')).hexdigest(),) -%}
    {%- do part_list.append(publish_section_title) %}
    [{{ publish_section_title }}]
    recipe = slapos.cookbook:publish
    -slave-reference = {{ slave_instance.get('slave_reference') }}
    {% endfor %}
    recipe = slapos.cookbook:publish.serialised
    available-region-list = {{ dumps(list(active_region_list)) }}
    -slave-reference = {{ slave_reference }}
    {%- for key, value in publish_dict.items() %}
    {{ key }} = {{ dumps(value) }}
    {%- endfor %}
    {% endfor %}
    [monitor-conf-parameters]
    monitor-title = Monitor
    password = ${monitor-htpasswd:passwd}
    [monitor-base-url-dict]
    {% for key, value in monitor_base_url_dict.items() -%}
    {% for key, value in monitor_base_url_dict.items() -%}
    {{ key }} = {{ value }}
    {% endfor %}
    {% endfor %}
    [buildout]
    extends = {{ instance_base_monitor }}
    parts +=
    slave-test-configuration
    {% for part in part_list %}
    {% for part in part_list %}
    {{ ' %s' % part }}
    {%- endfor %}
    {%- endif %}
    [publish-connection-information]
    recipe = slapos.cookbook:publish.serialised
    active-region-list = {{ dumps(list(active_region_list)) }}
    sla-computer_guid = {{ dumps(slap_configuration['computer']) }}
    sla-instance_guid = {{ dumps(slap_configuration['instance-guid']) }}
    {%- endif %} {#- if slap_software_type == software_type #}
    software/monitor/instance.cfg
    View file @ 7ae4d31a
    ......@@ -32,6 +32,7 @@ template = ${template-monitor-edgetest:target}
    rendered = $${buildout:directory}/template-monitor-base-edgetest.cfg
    extensions = jinja2.ext.do
    context = import json_module json
    import hashlib_module hashlib
    key develop_eggs_directory buildout:develop-eggs-directory
    key eggs_directory buildout:eggs-directory
    key slapparameter_dict slap-configuration:configuration
    ......@@ -53,6 +54,7 @@ surykatka-binary = ${buildout:bin-directory}/${surykatka:script-name}
    template-surykatka-ini = ${template-surykatka-ini:target}
    context = import json_module json
    import hashlib_module hashlib
    key develop_eggs_directory buildout:develop-eggs-directory
    key eggs_directory buildout:eggs-directory
    section slap_configuration slap-configuration
    ......@@ -75,13 +77,8 @@ url = $${slap-connection:server-url}
    key = $${slap-connection:key-file}
    cert = $${slap-connection:cert-file}
    # Defaults
    configuration.check-status-code = 200
    configuration.check-http-header-dict = {}
    configuration.nameserver =
    configuration.check-frontend-ip =
    configuration.check-certificate-expiration-days = 15
    configuration.check-maximum-elapsed-time = 2
    configuration.failure-amount = 2
    configuration.nameserver-list =
    configuration.check-frontend-ip-list =
    # use monitor-base-port to have monitor listening on each instance
    # on different port and also on different port than other services
    # it makes it possible to instantiate it correctly on signle IP, for
    ......
    software/monitor/software.cfg.json
    View file @ 7ae4d31a
    ......@@ -15,14 +15,17 @@
    "description": "Cluster of bots to perform a distributed monitoring ",
    "request": "instance-edgetest-input-schema.json",
    "response": "instance-default-output-schema.json",
    "serialisation": "json-in-xml",
    "index": 1
    },
    "edgetest-slave": {
    "title": "Edge Test Slave",
    "shared": true,
    "software-type": "edgetest",
    "description": "Cluster of bots to perform a distributed monitoring ",
    "request": "instance-edgetest-slave-input-schema.json",
    "response": "instance-default-output-schema.json",
    "serialisation": "json-in-xml",
    "index": 2
    }
    }
    ......
    software/monitor/surykatka.ini.jinja2
    View file @ 7ae4d31a
    ......@@ -2,7 +2,6 @@
    INTERVAL = 120
    TIMEOUT = {{ timeout }}
    SQLITE = {{ db }}
    {%- set nameserver_list = nameserver.split() %}
    {%- if len(nameserver_list) > 0 %}
    NAMESERVER =
    {%- for nameserver_entry in sorted(nameserver_list) %}
    ......@@ -10,7 +9,7 @@ NAMESERVER =
    {%- endfor %}
    {% endif %}
    URL =
    {%- for slave in slave_instance_list | sort(attribute='slave_title') %}
    {%- for slave in slave_instance_list | sort(attribute='-slave-title') %}
    {%- if 'url' in slave %}
    {{ slave['url'] }}
    {%- endif -%}
    ......
    software/monitor/test/test.py
    View file @ 7ae4d31a
    ......@@ -26,11 +26,13 @@
    ##############################################################################
    import glob
    import hashlib
    import json
    import os
    import re
    import requests
    import subprocess
    import unittest
    import xml.etree.ElementTree as ET
    from slapos.recipe.librecipe import generateHashFromFiles
    from slapos.testing.testcase import makeModuleSetUpAndTestCaseClass
    ......@@ -69,8 +71,10 @@ class MonitorTestMixin:
    monitor_setup_url_key = 'monitor-setup-url'
    def test_monitor_setup(self):
    connection_parameter_dict = self\
    connection_parameter_dict_serialised = self\
    .computer_partition.getConnectionParameterDict()
    connection_parameter_dict = json.loads(
    connection_parameter_dict_serialised['_'])
    self.assertTrue(
    self.monitor_setup_url_key in connection_parameter_dict,
    '%s not in %s' % (self.monitor_setup_url_key, connection_parameter_dict))
    ......@@ -136,6 +140,7 @@ class MonitorTestMixin:
    class EdgeSlaveMixin(MonitorTestMixin):
    __partition_reference__ = 'edge'
    instance_max_retry = 20
    expected_connection_parameter_dict = {}
    @classmethod
    def getInstanceSoftwareType(cls):
    ......@@ -143,36 +148,37 @@ class EdgeSlaveMixin(MonitorTestMixin):
    def requestEdgetestSlave(self, partition_reference, partition_parameter_kw):
    software_url = self.getSoftwareURL()
    self.slap.request(
    return self.slap.request(
    software_release=software_url,
    software_type='edgetest',
    partition_reference=partition_reference,
    partition_parameter_kw=partition_parameter_kw,
    partition_parameter_kw={'_': json.dumps(partition_parameter_kw)},
    shared=True
    )
    def updateSurykatkaDict(self):
    for class_ in self.surykatka_dict:
    update_dict = {}
    update_dict['ini-file'] = os.path.join(
    self.bot_partition_path, 'etc', 'surykatka-%s.ini' % (class_,))
    update_dict['json-file'] = os.path.join(
    self.bot_partition_path, 'srv', 'surykatka-%s.json' % (class_,))
    update_dict['status-json'] = os.path.join(
    self.bot_partition_path, 'bin', 'surykatka-status-json-%s' % (class_,))
    update_dict['bot-promise'] = 'surykatka-bot-promise-%s.py' % (class_,)
    update_dict['status-cron'] = os.path.join(
    self.bot_partition_path, 'etc', 'cron.d', 'surykatka-status-%s' % (
    class_,))
    update_dict['db_file'] = os.path.join(
    self.bot_partition_path, 'srv', 'surykatka-%s.db' % (class_,))
    self.surykatka_dict[class_].update(update_dict)
    def setUp(self):
    self.bot_partition_path = os.path.join(
    self.slap.instance_directory,
    self.__partition_reference__ + '1')
    self.updateSurykatkaDict()
    for instance_reference in self.surykatka_dict:
    for class_ in self.surykatka_dict[instance_reference]:
    update_dict = {}
    update_dict['ini-file'] = os.path.join(
    self.slap.instance_directory, instance_reference, 'etc',
    'surykatka-%s.ini' % (class_,))
    update_dict['json-file'] = os.path.join(
    self.slap.instance_directory, instance_reference, 'srv',
    'surykatka-%s.json' % (class_,))
    update_dict['status-json'] = os.path.join(
    self.slap.instance_directory, instance_reference, 'bin',
    'surykatka-status-json-%s' % (class_,))
    update_dict['bot-promise'] = 'surykatka-bot-promise-%s.py' % (class_,)
    update_dict['status-cron'] = os.path.join(
    self.slap.instance_directory, instance_reference, 'etc',
    'cron.d', 'surykatka-status-%s' % (class_,))
    update_dict['db_file'] = os.path.join(
    self.slap.instance_directory, instance_reference, 'srv',
    'surykatka-%s.db' % (class_,))
    self.surykatka_dict[instance_reference][class_].update(update_dict)
    def setUpMonitorConfigurationList(self):
    self.monitor_configuration_list = [
    {
    'xmlUrl': 'https://[%s]:9700/public/feed' % (self._ipv6_address,),
    ......@@ -194,43 +200,65 @@ class EdgeSlaveMixin(MonitorTestMixin):
    }
    ]
    def setUp(self):
    self.updateSurykatkaDict()
    self.setUpMonitorConfigurationList()
    def assertSurykatkaIni(self):
    expected_init_path_list = []
    for instance_reference in self.surykatka_dict:
    expected_init_path_list.extend(
    [q['ini-file']
    for q in self.surykatka_dict[instance_reference].values()])
    self.assertEqual(
    set(
    glob.glob(
    os.path.join(self.bot_partition_path, 'etc', 'surykatka*.ini'))),
    {q['ini-file'] for q in self.surykatka_dict.values()}
    os.path.join(
    self.slap.instance_directory, '*', 'etc', 'surykatka*.ini'
    )
    )
    ),
    set(expected_init_path_list)
    )
    for info_dict in self.surykatka_dict.values():
    self.assertEqual(
    info_dict['expected_ini'].strip() % info_dict,
    open(info_dict['ini-file']).read().strip()
    )
    def assertPromiseContent(self, name, content):
    for instance_reference in self.surykatka_dict:
    for info_dict in self.surykatka_dict[instance_reference].values():
    self.assertEqual(
    info_dict['expected_ini'].strip() % info_dict,
    open(info_dict['ini-file']).read().strip()
    )
    def assertPromiseContent(self, instance_reference, name, content):
    promise = open(
    os.path.join(
    self.bot_partition_path, 'etc', 'plugin', name
    self.slap.instance_directory, instance_reference, 'etc', 'plugin', name
    )).read().strip()
    self.assertTrue(content in promise)
    def assertHttpQueryPromiseContent(self, instance_reference, name, content):
    hashed = 'http-query-%s-promise.py' % (
    hashlib.md5(('_' + name).encode('utf-8')).hexdigest(),)
    self.assertPromiseContent(instance_reference, hashed, content)
    def assertSurykatkaBotPromise(self):
    for info_dict in self.surykatka_dict.values():
    self.assertPromiseContent(
    info_dict['bot-promise'],
    "'report': 'bot_status'")
    self.assertPromiseContent(
    info_dict['bot-promise'],
    "'json-file': '%s'" % (info_dict['json-file'],)
    )
    for instance_reference in self.surykatka_dict:
    for info_dict in self.surykatka_dict[instance_reference].values():
    self.assertPromiseContent(
    instance_reference,
    info_dict['bot-promise'],
    "'report': 'bot_status'")
    self.assertPromiseContent(
    instance_reference,
    info_dict['bot-promise'],
    "'json-file': '%s'" % (info_dict['json-file'],),)
    def assertSurykatkaCron(self):
    for info_dict in self.surykatka_dict.values():
    self.assertEqual(
    '*/2 * * * * %s' % (info_dict['status-json'],),
    open(info_dict['status-cron']).read().strip()
    )
    for instance_reference in self.surykatka_dict:
    for info_dict in self.surykatka_dict[instance_reference].values():
    self.assertEqual(
    '*/2 * * * * %s' % (info_dict['status-json'],),
    open(info_dict['status-cron']).read().strip()
    )
    def initiateSurykatkaRun(self):
    try:
    ......@@ -239,17 +267,30 @@ class EdgeSlaveMixin(MonitorTestMixin):
    pass
    def assertSurykatkaStatusJSON(self):
    for info_dict in self.surykatka_dict.values():
    if os.path.exists(info_dict['json-file']):
    os.unlink(info_dict['json-file'])
    try:
    subprocess.check_call(info_dict['status-json'])
    except subprocess.CalledProcessError as e:
    self.fail('%s failed with code %s and message %s' % (
    info_dict['status-json'], e.returncode, e.output))
    with open(info_dict['json-file']) as fh:
    status_json = json.load(fh)
    self.assertIn('bot_status', status_json)
    for instance_reference in self.surykatka_dict:
    for info_dict in self.surykatka_dict[instance_reference].values():
    if os.path.exists(info_dict['json-file']):
    os.unlink(info_dict['json-file'])
    try:
    subprocess.check_call(info_dict['status-json'])
    except subprocess.CalledProcessError as e:
    self.fail('%s failed with code %s and message %s' % (
    info_dict['status-json'], e.returncode, e.output))
    with open(info_dict['json-file']) as fh:
    status_json = json.load(fh)
    self.assertIn('bot_status', status_json)
    def assertConnectionParameterDict(self):
    serialised = self.requestDefaultInstance().getConnectionParameterDict()
    connection_parameter_dict = json.loads(serialised['_'])
    # tested elsewhere
    connection_parameter_dict.pop('monitor-setup-url', None)
    # comes from instance-monitor.cfg.jinja2, not needed here
    connection_parameter_dict.pop('server_log_url', None)
    self.assertEqual(
    self.expected_connection_parameter_dict,
    connection_parameter_dict
    )
    def test(self):
    # Note: Those tests do not run surykatka and do not do real checks, as
    ......@@ -266,83 +307,202 @@ class EdgeSlaveMixin(MonitorTestMixin):
    self.assertSurykatkaBotPromise()
    self.assertSurykatkaPromises()
    self.assertSurykatkaCron()
    self.assertConnectionParameterDict()
    class TestEdge(EdgeSlaveMixin, SlapOSInstanceTestCase):
    expected_connection_parameter_dict = {
    'active-region-list': ['1'],
    'sla-computer_guid': 'local', 'sla-instance_guid': 'local-edge0'}
    surykatka_dict = {
    2: {'expected_ini': """[SURYKATKA]
    'edge1': {
    1: {'expected_ini': """[SURYKATKA]
    INTERVAL = 120
    TIMEOUT = 3
    SQLITE = %(db_file)s
    URL =
    https://www.checkmaximumelapsedtime1.org/"""},
    2: {'expected_ini': """[SURYKATKA]
    INTERVAL = 120
    TIMEOUT = 4
    SQLITE = %(db_file)s
    URL =
    https://www.erp5.com/
    https://www.erp5.org/"""}
    https://www.checkcertificateexpirationdays.org/
    https://www.checkfrontendiplist.org/
    https://www.checkhttpheaderdict.org/
    https://www.checkstatuscode.org/
    https://www.default.org/
    https://www.failureamount.org/"""},
    20: {'expected_ini': """[SURYKATKA]
    INTERVAL = 120
    TIMEOUT = 22
    SQLITE = %(db_file)s
    URL =
    https://www.checkmaximumelapsedtime20.org/"""},
    }
    }
    def assertSurykatkaPromises(self):
    self.assertPromiseContent(
    'http-query-backend-300-promise.py',
    "'ip-list': ''")
    self.assertPromiseContent(
    'http-query-backend-300-promise.py',
    "'report': 'http_query'")
    self.assertPromiseContent(
    'http-query-backend-300-promise.py',
    "'status-code': '300'")
    self.assertPromiseContent(
    'http-query-backend-300-promise.py',
    "'certificate-expiration-days': '15'")
    self.assertPromiseContent(
    'http-query-backend-300-promise.py',
    "'url': 'https://www.erp5.org/'")
    self.assertPromiseContent(
    'http-query-backend-300-promise.py',
    "'json-file': '%s'" % (self.surykatka_dict[2]['json-file'],)
    self.assertHttpQueryPromiseContent(
    'edge1',
    'checkcertificateexpirationdays',
    """extra_config_dict = { 'certificate-expiration-days': '20',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.checkcertificateexpirationdays.org/'}""" % (
    self.surykatka_dict['edge1'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge1',
    'checkhttpheaderdict',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{"A": "AAA"}',
    'ip-list': '',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.checkhttpheaderdict.org/'}""" % (
    self.surykatka_dict['edge1'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge1',
    'checkmaximumelapsedtime1',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '',
    'json-file': '%s',
    'maximum-elapsed-time': '1',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.checkmaximumelapsedtime1.org/'}""" % (
    self.surykatka_dict['edge1'][1]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge1',
    'checkmaximumelapsedtime20',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '',
    'json-file': '%s',
    'maximum-elapsed-time': '20',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.checkmaximumelapsedtime20.org/'}""" % (
    self.surykatka_dict['edge1'][20]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge1',
    'checkstatuscode',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '300',
    'url': 'https://www.checkstatuscode.org/'}""" % (
    self.surykatka_dict['edge1'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge1',
    'default',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.default.org/'}""" % (
    self.surykatka_dict['edge1'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge1',
    'failureamount',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '10',
    'http-header-dict': '{}',
    'ip-list': '',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.failureamount.org/'}""" % (
    self.surykatka_dict['edge1'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge1',
    'checkfrontendiplist',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '128.129.130.131 131.134.135.136',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.checkfrontendiplist.org/'}""" % (
    self.surykatka_dict['edge1'][2]['json-file'],))
    def requestEdgetestSlaves(self):
    self.requestEdgetestSlave(
    'default',
    {'url': 'https://www.default.org/'},
    )
    self.assertPromiseContent(
    'http-query-backend-300-promise.py',
    "'failure-amount': '2'"
    self.requestEdgetestSlave(
    'checkstatuscode',
    {'url': 'https://www.checkstatuscode.org/', 'check-status-code': 300},
    )
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'ip-list': ''")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'report': 'http_query'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'status-code': '200'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'certificate-expiration-days': '15'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'url': 'https://www.erp5.com/'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'json-file': '%s'" % (self.surykatka_dict[2]['json-file'],)
    self.requestEdgetestSlave(
    'checkhttpheaderdict',
    {'url': 'https://www.checkhttpheaderdict.org/',
    'check-http-header-dict': {"A": "AAA"}},
    )
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'failure-amount': '2'"
    self.requestEdgetestSlave(
    'checkcertificateexpirationdays',
    {'url': 'https://www.checkcertificateexpirationdays.org/',
    'check-certificate-expiration-days': '20'},
    )
    def requestEdgetestSlaves(self):
    self.requestEdgetestSlave(
    'backend',
    {'url': 'https://www.erp5.com/'},
    'checkmaximumelapsedtime20',
    {'url': 'https://www.checkmaximumelapsedtime20.org/',
    'check-maximum-elapsed-time': 20},
    )
    self.requestEdgetestSlave(
    'checkmaximumelapsedtime1',
    {'url': 'https://www.checkmaximumelapsedtime1.org/',
    'check-maximum-elapsed-time': 1},
    )
    self.requestEdgetestSlave(
    'backend-300',
    {'url': 'https://www.erp5.org/', 'check-status-code': '300'},
    'failureamount',
    {'url': 'https://www.failureamount.org/', 'failure-amount': '10'},
    )
    self.requestEdgetestSlave(
    'checkfrontendiplist',
    {'url': 'https://www.checkfrontendiplist.org/',
    'check-frontend-ip-list': ['128.129.130.131', '131.134.135.136']},
    )
    class TestEdgeNameserverCheckFrontendIp(
    class TestEdgeNameserverListCheckFrontendIpList(
    EdgeSlaveMixin, SlapOSInstanceTestCase):
    expected_connection_parameter_dict = {
    'active-region-list': ['1'], 'sla-computer_guid': 'local',
    'sla-instance_guid': 'local-edge0'}
    surykatka_dict = {
    2: {'expected_ini': """[SURYKATKA]
    'edge1': {
    2: {'expected_ini': """[SURYKATKA]
    INTERVAL = 120
    TIMEOUT = 4
    SQLITE = %(db_file)s
    ......@@ -352,37 +512,45 @@ NAMESERVER =
    URL =
    https://www.erp5.com/"""}
    }
    }
    @classmethod
    def getInstanceParameterDict(cls):
    return {
    'nameserver': '127.0.1.1 127.0.1.2',
    'check-frontend-ip': '127.0.0.1 127.0.0.2',
    }
    return {'_': json.dumps({
    'nameserver-list': ['127.0.1.1', '127.0.1.2'],
    'check-frontend-ip-list': ['127.0.0.1', '127.0.0.2'],
    })}
    def assertSurykatkaPromises(self):
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    self.assertHttpQueryPromiseContent(
    'edge1',
    'backend',
    "'ip-list': '127.0.0.1 127.0.0.2'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    self.assertHttpQueryPromiseContent(
    'edge1',
    'backend',
    "'report': 'http_query'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    self.assertHttpQueryPromiseContent(
    'edge1',
    'backend',
    "'status-code': '200'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    self.assertHttpQueryPromiseContent(
    'edge1',
    'backend',
    "'certificate-expiration-days': '15'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    self.assertHttpQueryPromiseContent(
    'edge1',
    'backend',
    "'url': 'https://www.erp5.com/'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'json-file': '%s'" % (self.surykatka_dict[2]['json-file'],)
    self.assertHttpQueryPromiseContent(
    'edge1',
    'backend',
    "'json-file': '%s'" % (self.surykatka_dict['edge1'][2]['json-file'],)
    )
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    self.assertHttpQueryPromiseContent(
    'edge1',
    'backend',
    "'failure-amount': '2'"
    )
    ......@@ -393,426 +561,833 @@ URL =
    )
    class TestEdgeCheckStatusCode(EdgeSlaveMixin, SlapOSInstanceTestCase):
    class TestEdgeSlaveNotJson(
    EdgeSlaveMixin, SlapOSInstanceTestCase):
    surykatka_dict = {
    2: {'expected_ini': """[SURYKATKA]
    'edge1': {
    2: {'expected_ini': """[SURYKATKA]
    INTERVAL = 120
    TIMEOUT = 4
    SQLITE = %(db_file)s
    URL =
    https://www.erp5.com/
    https://www.erp5.org/"""}
    https://www.erp5.com/"""}
    }
    }
    @classmethod
    def getInstanceParameterDict(cls):
    return {
    'check-status-code': '500',
    }
    # non-json provided in slave '_' results with damaging the cluster
    # test here is to expose real problem, which has no solution for now
    @unittest.expectedFailure
    def test(self):
    EdgeSlaveMixin.test()
    def assertSurykatkaPromises(self):
    self.assertPromiseContent(
    'http-query-backend-501-promise.py',
    "'ip-list': ''")
    self.assertPromiseContent(
    'http-query-backend-501-promise.py',
    "'report': 'http_query'")
    self.assertPromiseContent(
    'http-query-backend-501-promise.py',
    "'status-code': '501'")
    self.assertPromiseContent(
    'http-query-backend-501-promise.py',
    "'certificate-expiration-days': '15'")
    self.assertPromiseContent(
    'http-query-backend-501-promise.py',
    "'url': 'https://www.erp5.org/'")
    self.assertPromiseContent(
    'http-query-backend-501-promise.py',
    "'json-file': '%s'" % (self.surykatka_dict[2]['json-file'],)
    )
    self.assertPromiseContent(
    'http-query-backend-501-promise.py',
    "'failure-amount': '2'"
    )
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'ip-list': ''")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'report': 'http_query'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'status-code': '500'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'certificate-expiration-days': '15'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'url': 'https://www.erp5.com/'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'json-file': '%s'" % (self.surykatka_dict[2]['json-file'],)
    )
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'failure-amount': '2'"
    )
    self.assertHttpQueryPromiseContent(
    'default',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.default.org/'}""" % (
    self.surykatka_dict[2]['json-file'],))
    def requestEdgetestSlaves(self):
    self.requestEdgetestSlave(
    'backend',
    {'url': 'https://www.erp5.com/'},
    'default',
    {'url': 'https://www.default.org/'},
    )
    self.requestEdgetestSlave(
    'backend-501',
    {'url': 'https://www.erp5.org/', 'check-status-code': '501'},
    software_url = self.getSoftwareURL()
    self.slap.request(
    software_release=software_url,
    software_type='edgetest',
    partition_reference='notajson',
    partition_parameter_kw={'_': 'notajson'},
    shared=True
    )
    class TestEdgeCheckHTTPHeaderDict(EdgeSlaveMixin, SlapOSInstanceTestCase):
    surykatka_dict = {
    2: {'expected_ini': """[SURYKATKA]
    INTERVAL = 120
    TIMEOUT = 4
    SQLITE = %(db_file)s
    URL =
    https://www.erp5.com/
    https://www.erp5.org/"""}
    }
    class TestEdgeRegion(EdgeSlaveMixin, SlapOSInstanceTestCase):
    def setUpMonitorConfigurationList(self):
    self.monitor_configuration_list = [
    {
    'htmlUrl': 'https://[%s]:9700/public/feed' % (self._ipv6_address,),
    'text': 'testing partition 0',
    'title': 'testing partition 0',
    'type': 'rss',
    'url': 'https://[%s]:9700/share/private/' % (self._ipv6_address,),
    'version': 'RSS',
    'xmlUrl': 'https://[%s]:9700/public/feed' % (self._ipv6_address,)
    },
    {
    'htmlUrl': 'https://[%s]:9701/public/feed' % (self._ipv6_address,),
    'text': 'edgebot-Region One',
    'title': 'edgebot-Region One',
    'type': 'rss',
    'url': 'https://[%s]:9701/share/private/' % (self._ipv6_address,),
    'version': 'RSS',
    'xmlUrl': 'https://[%s]:9701/public/feed' % (self._ipv6_address,)
    },
    {
    'htmlUrl': 'https://[%s]:9702/public/feed' % (self._ipv6_address,),
    'text': 'edgebot-Region Three',
    'title': 'edgebot-Region Three',
    'type': 'rss',
    'url': 'https://[%s]:9702/share/private/' % (self._ipv6_address,),
    'version': 'RSS',
    'xmlUrl': 'https://[%s]:9702/public/feed' % (self._ipv6_address,)
    },
    {
    'htmlUrl': 'https://[%s]:9703/public/feed' % (self._ipv6_address,),
    'text': 'edgebot-Region Two',
    'title': 'edgebot-Region Two',
    'type': 'rss',
    'url': 'https://[%s]:9703/share/private/' % (self._ipv6_address,),
    'version': 'RSS',
    'xmlUrl': 'https://[%s]:9703/public/feed' % (self._ipv6_address,)
    }
    ]
    @classmethod
    def getInstanceParameterDict(cls):
    return {
    'check-http-header-dict':
    '{"B": "BBB"}',
    def setUpClassParameter(cls):
    cls.instance_parameter_dict = {
    'region-dict': {
    'Region One': {
    'sla-computer_guid': 'local',
    'state': 'started',
    'nameserver-list': ['127.0.1.1', '127.0.1.2'],
    'check-frontend-ip-list': ['127.0.1.3', '127.0.1.4'],
    },
    'Region Two': {
    'sla-computer_guid': 'local',
    'state': 'started',
    'nameserver-list': ['127.0.2.1', '127.0.2.2'],
    },
    'Region Three': {
    'sla-computer_guid': 'local',
    'state': 'started',
    'check-frontend-ip-list': ['127.0.3.1', '127.0.3.2'],
    }
    }
    }
    cls.expected_connection_parameter_dict = {
    'active-region-list': [
    'Region One', 'Region Three', 'Region Two'],
    'sla-computer_guid': 'local', 'sla-instance_guid': 'local-edge0'}
    def assertSurykatkaPromises(self):
    self.assertPromiseContent(
    'http-query-backend-http-header-promise.py',
    "'ip-list': ''")
    self.assertPromiseContent(
    'http-query-backend-http-header-promise.py',
    "'report': 'http_query'")
    self.assertPromiseContent(
    'http-query-backend-http-header-promise.py',
    "'status-code': '200'")
    self.assertPromiseContent(
    'http-query-backend-http-header-promise.py',
    "'http-header-dict': '{\"A\": \"AAA\"}'")
    self.assertPromiseContent(
    'http-query-backend-http-header-promise.py',
    "'certificate-expiration-days': '15'")
    self.assertPromiseContent(
    'http-query-backend-http-header-promise.py',
    "'url': 'https://www.erp5.org/'")
    self.assertPromiseContent(
    'http-query-backend-http-header-promise.py',
    "'json-file': '%s'" % (self.surykatka_dict[2]['json-file'],)
    )
    self.assertPromiseContent(
    'http-query-backend-http-header-promise.py',
    "'failure-amount': '2'"
    )
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'ip-list': ''")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'report': 'http_query'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'status-code': '200'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'http-header-dict': '{\"B\": \"BBB\"}'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'certificate-expiration-days': '15'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'url': 'https://www.erp5.com/'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'json-file': '%s'" % (self.surykatka_dict[2]['json-file'],)
    )
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'failure-amount': '2'"
    )
    def requestEdgetestSlaves(self):
    self.requestEdgetestSlave(
    'backend',
    {'url': 'https://www.erp5.com/'},
    )
    self.requestEdgetestSlave(
    'backend-http-header',
    {'url': 'https://www.erp5.org/', 'check-http-header-dict': '{"A": "AAA"}'},
    )
    class TestEdgeCheckCertificateExpirationDays(
    EdgeSlaveMixin, SlapOSInstanceTestCase):
    surykatka_dict = {
    2: {'expected_ini': """[SURYKATKA]
    @classmethod
    def setUpClass(cls):
    cls.setUpClassParameter()
    super().setUpClass()
    def setUpParameter(self):
    self.surykatka_dict = {
    'edge1': {
    2: {'expected_ini': """[SURYKATKA]
    INTERVAL = 120
    TIMEOUT = 4
    SQLITE = %(db_file)s
    URL =
    https://www.erp5.com/
    https://www.erp5.org/"""}
    }
    @classmethod
    def getInstanceParameterDict(cls):
    return {
    'check-certificate-expiration-days': '10',
    }
    def assertSurykatkaPromises(self):
    self.assertPromiseContent(
    'http-query-backend-20-promise.py',
    "'ip-list': ''")
    self.assertPromiseContent(
    'http-query-backend-20-promise.py',
    "'report': 'http_query'")
    self.assertPromiseContent(
    'http-query-backend-20-promise.py',
    "'status-code': '200'")
    self.assertPromiseContent(
    'http-query-backend-20-promise.py',
    "'certificate-expiration-days': '20'")
    self.assertPromiseContent(
    'http-query-backend-20-promise.py',
    "'url': 'https://www.erp5.org/'")
    self.assertPromiseContent(
    'http-query-backend-20-promise.py',
    "'json-file': '%s'" % (self.surykatka_dict[2]['json-file'],)
    )
    self.assertPromiseContent(
    'http-query-backend-20-promise.py',
    "'failure-amount': '2'"
    )
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'ip-list': ''")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'report': 'http_query'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'status-code': '200'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'certificate-expiration-days': '10'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'url': 'https://www.erp5.com/'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'json-file': '%s'" % (self.surykatka_dict[2]['json-file'],)
    )
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'failure-amount': '2'"
    )
    def requestEdgetestSlaves(self):
    self.requestEdgetestSlave(
    'backend',
    {'url': 'https://www.erp5.com/'},
    )
    self.requestEdgetestSlave(
    'backend-20',
    {'url': 'https://www.erp5.org/',
    'check-certificate-expiration-days': '20'},
    )
    NAMESERVER =
    127.0.1.1
    127.0.1.2
    class TestEdgeCheckMaximumElapsedTime(
    EdgeSlaveMixin, SlapOSInstanceTestCase):
    surykatka_dict = {
    5: {'expected_ini': """[SURYKATKA]
    INTERVAL = 120
    TIMEOUT = 7
    SQLITE = %(db_file)s
    URL =
    https://www.erp5.com/"""},
    20: {'expected_ini': """[SURYKATKA]
    https://www.all.org/
    https://www.globalcheck.org/
    https://www.onetwo.org/
    https://www.specificcheck.org/
    https://www.specificoverride.org/"""},
    },
    'edge2': {
    2: {'expected_ini': """[SURYKATKA]
    INTERVAL = 120
    TIMEOUT = 22
    TIMEOUT = 4
    SQLITE = %(db_file)s
    URL =
    https://www.erp5.org/"""},
    1: {'expected_ini': """[SURYKATKA]
    https://www.all.org/
    https://www.three.org/"""},
    },
    'edge3': {
    2: {'expected_ini': """[SURYKATKA]
    INTERVAL = 120
    TIMEOUT = 3
    TIMEOUT = 4
    SQLITE = %(db_file)s
    NAMESERVER =
    127.0.2.1
    127.0.2.2
    URL =
    https://www.erp5.net/"""}
    }
    https://www.all.org/
    https://www.onetwo.org/
    https://www.parialmiss.org/
    https://www.specificoverride.org/"""},
    }
    }
    def setUp(self):
    self.setUpParameter()
    super().setUp()
    @classmethod
    def getInstanceParameterDict(cls):
    return {
    'check-maximum-elapsed-time': '5',
    }
    return {'_': json.dumps(cls.instance_parameter_dict)}
    slave_parameter_dict_dict = {
    'all': {
    'url': 'https://www.all.org/'
    },
    'onetwo': {
    'url': 'https://www.onetwo.org/',
    'region-dict': {'Region One': {}, 'Region Two': {}}
    },
    'three': {
    'url': 'https://www.three.org/',
    'region-dict': {'Region Three': {}}
    },
    'missed': {
    'url': 'https://www.missed.org/',
    'region-dict': {'Region Non Existing': {}}
    },
    'partialmiss': {
    'url': 'https://www.parialmiss.org/',
    'region-dict': {'Region Two': {}, 'Region Non Existing': {}}
    },
    'specificcheck': {
    'url': 'https://www.specificcheck.org/',
    'region-dict': {
    'Region One': {'check-frontend-ip-list': ['99.99.99.1', '99.99.99.2']}}
    },
    'globalcheck': {
    'url': 'https://www.globalcheck.org/',
    'check-frontend-ip-list': ['99.99.99.3', '99.99.99.4'],
    'region-dict': {'Region One': {}}
    },
    'specificoverride': {
    'url': 'https://www.specificoverride.org/',
    'check-frontend-ip-list': ['99.99.99.5', '99.99.99.6'],
    'region-dict': {
    'Region One': {'check-frontend-ip-list': ['99.99.99.7', '99.99.99.8']},
    'Region Two': {}}
    },
    }
    def requestEdgetestSlaves(self):
    for reference, parameter_dict in self.slave_parameter_dict_dict.items():
    self.requestEdgetestSlave(reference, parameter_dict)
    def assertSurykatkaPromises(self):
    self.assertPromiseContent(
    'http-query-backend-20-promise.py',
    "'ip-list': ''")
    self.assertPromiseContent(
    'http-query-backend-20-promise.py',
    "'report': 'http_query'")
    self.assertPromiseContent(
    'http-query-backend-20-promise.py',
    "'status-code': '200'")
    self.assertPromiseContent(
    'http-query-backend-20-promise.py',
    "'maximum-elapsed-time': '20'")
    self.assertPromiseContent(
    'http-query-backend-20-promise.py',
    "'url': 'https://www.erp5.org/'")
    self.assertPromiseContent(
    'http-query-backend-20-promise.py',
    "'json-file': '%s'" % (self.surykatka_dict[20]['json-file'],)
    )
    self.assertPromiseContent(
    'http-query-backend-20-promise.py',
    "'failure-amount': '2'"
    )
    self.assertHttpQueryPromiseContent(
    'edge1',
    'all',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '127.0.1.3 127.0.1.4',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.all.org/'}""" % (
    self.surykatka_dict['edge1'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge1',
    'specificcheck',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '99.99.99.1 99.99.99.2',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.specificcheck.org/'}""" % (
    self.surykatka_dict['edge1'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge1',
    'globalcheck',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '99.99.99.3 99.99.99.4',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.globalcheck.org/'}""" % (
    self.surykatka_dict['edge1'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge1',
    'specificoverride',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '99.99.99.7 99.99.99.8',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.specificoverride.org/'}""" % (
    self.surykatka_dict['edge1'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge1',
    'onetwo',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '127.0.1.3 127.0.1.4',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.onetwo.org/'}""" % (
    self.surykatka_dict['edge1'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge2',
    'all',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '127.0.3.1 127.0.3.2',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.all.org/'}""" % (
    self.surykatka_dict['edge2'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge2',
    'three',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '127.0.3.1 127.0.3.2',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.three.org/'}""" % (
    self.surykatka_dict['edge2'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge3',
    'all',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.all.org/'}""" % (
    self.surykatka_dict['edge3'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge3',
    'onetwo',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.onetwo.org/'}""" % (
    self.surykatka_dict['edge3'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge3',
    'partialmiss',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.parialmiss.org/'}""" % (
    self.surykatka_dict['edge3'][2]['json-file'],))
    self.assertHttpQueryPromiseContent(
    'edge3',
    'specificoverride',
    """extra_config_dict = { 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '99.99.99.5 99.99.99.6',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.specificoverride.org/'}""" % (
    self.surykatka_dict['edge3'][2]['json-file'],))
    self.assertPromiseContent(
    'http-query-backend-default-promise.py',
    "'ip-list': ''")
    self.assertPromiseContent(
    'http-query-backend-default-promise.py',
    "'report': 'http_query'")
    self.assertPromiseContent(
    'http-query-backend-default-promise.py',
    "'status-code': '200'")
    self.assertPromiseContent(
    'http-query-backend-default-promise.py',
    "'maximum-elapsed-time': '5'")
    self.assertPromiseContent(
    'http-query-backend-default-promise.py',
    "'url': 'https://www.erp5.com/'")
    self.assertPromiseContent(
    'http-query-backend-default-promise.py',
    "'json-file': '%s'" % (self.surykatka_dict[5]['json-file'],)
    )
    self.assertPromiseContent(
    'http-query-backend-default-promise.py',
    "'failure-amount': '2'"
    )
    def test(self):
    super(TestEdgeRegion, self).test()
    self.assertSlaveConnectionParameterDict()
    maxDiff = None
    expected_slave_connection_parameter_dict_dict = {
    'all': {
    'available-region-list': [
    'Region One', 'Region Three', 'Region Two'],
    'assigned-region-dict': {
    'Region One': {
    'check-frontend-ip-list': ['127.0.1.3', '127.0.1.4'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    },
    'Region Three': {
    'check-frontend-ip-list': ['127.0.3.1', '127.0.3.2'],
    'nameserver-list': []
    },
    'Region Two': {
    'check-frontend-ip-list': [],
    'nameserver-list': ['127.0.2.1', '127.0.2.2']
    }
    }
    },
    'onetwo': {
    'available-region-list': [
    'Region One', 'Region Three', 'Region Two'],
    'assigned-region-dict': {
    'Region One': {
    'check-frontend-ip-list': ['127.0.1.3', '127.0.1.4'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    },
    'Region Two': {
    'check-frontend-ip-list': [],
    'nameserver-list': ['127.0.2.1', '127.0.2.2']
    }
    }
    },
    'specificcheck': {
    'assigned-region-dict': {
    'Region One': {
    'check-frontend-ip-list': ['99.99.99.1', '99.99.99.2'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    }
    },
    'available-region-list': [
    'Region One', 'Region Three', 'Region Two']
    },
    'specificoverride': {
    'assigned-region-dict': {
    'Region One': {
    'check-frontend-ip-list': ['99.99.99.7', '99.99.99.8'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    },
    'Region Two': {
    'check-frontend-ip-list': ['99.99.99.5', '99.99.99.6'],
    'nameserver-list': ['127.0.2.1', '127.0.2.2']
    }
    },
    'available-region-list': [
    'Region One', 'Region Three', 'Region Two']
    },
    'three': {
    'available-region-list': [
    'Region One', 'Region Three', 'Region Two'],
    'assigned-region-dict': {
    'Region Three': {
    'check-frontend-ip-list': ['127.0.3.1', '127.0.3.2'],
    'nameserver-list': []
    }
    }
    },
    'globalcheck': {
    'assigned-region-dict': {
    'Region One': {
    'check-frontend-ip-list': ['99.99.99.3', '99.99.99.4'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    }
    },
    'available-region-list': [
    'Region One', 'Region Three', 'Region Two']
    },
    'missed': {
    'available-region-list': [
    'Region One', 'Region Three', 'Region Two'],
    'assigned-region-dict': {
    }
    },
    'partialmiss': {
    'available-region-list': [
    'Region One', 'Region Three', 'Region Two'],
    'assigned-region-dict': {
    'Region Two': {
    'check-frontend-ip-list': [],
    'nameserver-list': ['127.0.2.1', '127.0.2.2']
    }
    }
    }
    }
    self.assertPromiseContent(
    'http-query-backend-1-promise.py',
    "'ip-list': ''")
    self.assertPromiseContent(
    'http-query-backend-1-promise.py',
    "'report': 'http_query'")
    self.assertPromiseContent(
    'http-query-backend-1-promise.py',
    "'status-code': '200'")
    self.assertPromiseContent(
    'http-query-backend-1-promise.py',
    "'maximum-elapsed-time': '1'")
    self.assertPromiseContent(
    'http-query-backend-1-promise.py',
    "'url': 'https://www.erp5.net/'")
    self.assertPromiseContent(
    'http-query-backend-1-promise.py',
    "'json-file': '%s'" % (self.surykatka_dict[1]['json-file'],)
    )
    self.assertPromiseContent(
    'http-query-backend-1-promise.py',
    "'failure-amount': '2'"
    def assertSlaveConnectionParameterDict(self):
    slave_connection_parameter_dict_dict = {}
    for reference, parameter_dict in self.slave_parameter_dict_dict.items():
    slave_connection_parameter_dict_dict[
    reference] = self.requestEdgetestSlave(
    reference, parameter_dict).getConnectionParameterDict()
    # unload the json
    slave_connection_parameter_dict_dict[
    reference] = json.loads(
    slave_connection_parameter_dict_dict[reference].pop('_'))
    self.assertEqual(
    self.expected_slave_connection_parameter_dict_dict,
    slave_connection_parameter_dict_dict
    )
    def requestEdgetestSlaves(self):
    self.requestEdgetestSlave(
    'backend-default',
    {'url': 'https://www.erp5.com/'},
    )
    self.requestEdgetestSlave(
    'backend-20',
    {'url': 'https://www.erp5.org/',
    'check-maximum-elapsed-time': '20'},
    )
    self.requestEdgetestSlave(
    'backend-1',
    {'url': 'https://www.erp5.net/',
    'check-maximum-elapsed-time': '1'},
    )
    class TestEdgeRegionDestroyed(TestEdgeRegion):
    def setUpMonitorConfigurationList(self):
    # already for destroyed case, as test_monitor_setup will be called after
    # test
    self.monitor_configuration_list = [
    {
    'htmlUrl': 'https://[%s]:9700/public/feed' % (self._ipv6_address,),
    'text': 'testing partition 0',
    'title': 'testing partition 0',
    'type': 'rss',
    'url': 'https://[%s]:9700/share/private/' % (self._ipv6_address,),
    'version': 'RSS',
    'xmlUrl': 'https://[%s]:9700/public/feed' % (self._ipv6_address,)
    },
    {
    'htmlUrl': 'https://[%s]:9701/public/feed' % (self._ipv6_address,),
    'text': 'edgebot-Region One',
    'title': 'edgebot-Region One',
    'type': 'rss',
    'url': 'https://[%s]:9701/share/private/' % (self._ipv6_address,),
    'version': 'RSS',
    'xmlUrl': 'https://[%s]:9701/public/feed' % (self._ipv6_address,)
    },
    {
    'htmlUrl': 'https://[%s]:9703/public/feed' % (self._ipv6_address,),
    'text': 'edgebot-Region Two',
    'title': 'edgebot-Region Two',
    'type': 'rss',
    'url': 'https://[%s]:9703/share/private/' % (self._ipv6_address,),
    'version': 'RSS',
    'xmlUrl': 'https://[%s]:9703/public/feed' % (self._ipv6_address,)
    }
    ]
    class TestEdgeFailureAmount(
    EdgeSlaveMixin, SlapOSInstanceTestCase):
    surykatka_dict = {
    2: {'expected_ini': """[SURYKATKA]
    def test(self):
    super(TestEdgeRegionDestroyed, self).test()
    # hack around @classmethod
    self.__class__.instance_parameter_dict[
    'region-dict']['Region Three']['state'] = 'destroyed'
    # Region was removed
    self.__class__.expected_connection_parameter_dict[
    'active-region-list'].remove('Region Three')
    self.__class__._instance_parameter_dict = self.getInstanceParameterDict()
    self.requestDefaultInstance()
    # give time to stabilise the tree
    self.slap.waitForInstance(max_retry=4)
    self.assertConnectionParameterDict()
    self.expected_slave_connection_parameter_dict_dict = {
    'all': {
    'available-region-list': [
    'Region One', 'Region Two'],
    'assigned-region-dict': {
    'Region One': {
    'check-frontend-ip-list': ['127.0.1.3', '127.0.1.4'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    },
    'Region Two': {
    'check-frontend-ip-list': [],
    'nameserver-list': ['127.0.2.1', '127.0.2.2']
    }
    }
    },
    'onetwo': {
    'available-region-list': [
    'Region One', 'Region Two'],
    'assigned-region-dict': {
    'Region One': {
    'check-frontend-ip-list': ['127.0.1.3', '127.0.1.4'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    },
    'Region Two': {
    'check-frontend-ip-list': [],
    'nameserver-list': ['127.0.2.1', '127.0.2.2']
    }
    }
    },
    'specificcheck': {
    'assigned-region-dict': {
    'Region One': {
    'check-frontend-ip-list': ['99.99.99.1', '99.99.99.2'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    }
    },
    'available-region-list': [
    'Region One', 'Region Two']
    },
    'specificoverride': {
    'assigned-region-dict': {
    'Region One': {
    'check-frontend-ip-list': ['99.99.99.7', '99.99.99.8'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    },
    'Region Two': {
    'check-frontend-ip-list': ['99.99.99.5', '99.99.99.6'],
    'nameserver-list': ['127.0.2.1', '127.0.2.2']
    }
    },
    'available-region-list': [
    'Region One', 'Region Two']
    },
    'three': {
    'assigned-region-dict': {},
    'available-region-list': [
    'Region One', 'Region Two'],
    },
    'globalcheck': {
    'assigned-region-dict': {
    'Region One': {
    'check-frontend-ip-list': ['99.99.99.3', '99.99.99.4'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    }
    },
    'available-region-list': [
    'Region One', 'Region Two']
    },
    'missed': {
    'available-region-list': [
    'Region One', 'Region Two'],
    'assigned-region-dict': {
    }
    },
    'partialmiss': {
    'available-region-list': [
    'Region One', 'Region Two'],
    'assigned-region-dict': {
    'Region Two': {
    'check-frontend-ip-list': [],
    'nameserver-list': ['127.0.2.1', '127.0.2.2']
    }
    }
    }
    }
    self.assertSlaveConnectionParameterDict()
    class TestEdgeRegionAdded(TestEdgeRegion):
    def setUpMonitorConfigurationList(self):
    # already for added case, as test_monitor_setup will be called after test
    self.monitor_configuration_list = [
    {
    'htmlUrl': 'https://[%s]:9700/public/feed' % (self._ipv6_address,),
    'text': 'testing partition 0',
    'title': 'testing partition 0',
    'type': 'rss',
    'url': 'https://[%s]:9700/share/private/' % (self._ipv6_address,),
    'version': 'RSS',
    'xmlUrl': 'https://[%s]:9700/public/feed' % (self._ipv6_address,)
    },
    {
    'htmlUrl': 'https://[%s]:9701/public/feed' % (self._ipv6_address,),
    'text': 'edgebot-Region Four',
    'title': 'edgebot-Region Four',
    'type': 'rss',
    'url': 'https://[%s]:9701/share/private/' % (self._ipv6_address,),
    'version': 'RSS',
    'xmlUrl': 'https://[%s]:9701/public/feed' % (self._ipv6_address,)
    },
    {
    'htmlUrl': 'https://[%s]:9702/public/feed' % (self._ipv6_address,),
    'text': 'edgebot-Region One',
    'title': 'edgebot-Region One',
    'type': 'rss',
    'url': 'https://[%s]:9702/share/private/' % (self._ipv6_address,),
    'version': 'RSS',
    'xmlUrl': 'https://[%s]:9702/public/feed' % (self._ipv6_address,)
    },
    {
    'htmlUrl': 'https://[%s]:9703/public/feed' % (self._ipv6_address,),
    'text': 'edgebot-Region Three',
    'title': 'edgebot-Region Three',
    'type': 'rss',
    'url': 'https://[%s]:9703/share/private/' % (self._ipv6_address,),
    'version': 'RSS',
    'xmlUrl': 'https://[%s]:9703/public/feed' % (self._ipv6_address,)
    },
    {
    'htmlUrl': 'https://[%s]:9704/public/feed' % (self._ipv6_address,),
    'text': 'edgebot-Region Two',
    'title': 'edgebot-Region Two',
    'type': 'rss',
    'url': 'https://[%s]:9704/share/private/' % (self._ipv6_address,),
    'version': 'RSS',
    'xmlUrl': 'https://[%s]:9704/public/feed' % (self._ipv6_address,)
    }
    ]
    def test(self):
    super(TestEdgeRegionAdded, self).test()
    self.__class__.instance_parameter_dict['region-dict']['Region Four'] = {
    'sla-computer_guid': 'local',
    'state': 'started',
    'nameserver-list': ['127.0.4.1', '127.0.4.2'],
    'check-frontend-ip-list': ['127.0.4.3', '127.0.4.4'],
    }
    # Region was added
    self.__class__.expected_connection_parameter_dict[
    'active-region-list'].insert(0, 'Region Four')
    self.__class__._instance_parameter_dict = self.getInstanceParameterDict()
    self.requestDefaultInstance()
    # give time to stabilise the tree, 6 times as new node is added
    self.slap.waitForInstance(max_retry=6)
    # XXX: few more times, but ignoring good result from promises, as there is
    # "Unknown Instance" of just added node which is not caught by any
    # promise, but in the end it shall get better
    for f in range(5):
    try:
    self.slap.waitForInstance()
    except Exception:
    pass
    self.slap.waitForInstance()
    self.assertConnectionParameterDict()
    self.expected_slave_connection_parameter_dict_dict = {
    'all': {
    'available-region-list': [
    'Region Four', 'Region One', 'Region Three', 'Region Two'],
    'assigned-region-dict': {
    'Region Four': {
    'check-frontend-ip-list': ['127.0.4.3', '127.0.4.4'],
    'nameserver-list': ['127.0.4.1', '127.0.4.2']
    },
    'Region One': {
    'check-frontend-ip-list': ['127.0.1.3', '127.0.1.4'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    },
    'Region Three': {
    'check-frontend-ip-list': ['127.0.3.1', '127.0.3.2'],
    'nameserver-list': []
    },
    'Region Two': {
    'check-frontend-ip-list': [],
    'nameserver-list': ['127.0.2.1', '127.0.2.2']
    }
    }
    },
    'onetwo': {
    'available-region-list': [
    'Region Four', 'Region One', 'Region Three', 'Region Two'],
    'assigned-region-dict': {
    'Region One': {
    'check-frontend-ip-list': ['127.0.1.3', '127.0.1.4'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    },
    'Region Two': {
    'check-frontend-ip-list': [],
    'nameserver-list': ['127.0.2.1', '127.0.2.2']
    }
    }
    },
    'specificcheck': {
    'available-region-list': [
    'Region Four', 'Region One', 'Region Three', 'Region Two'],
    'assigned-region-dict': {
    'Region One': {
    'check-frontend-ip-list': ['99.99.99.1', '99.99.99.2'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    }
    },
    },
    'specificoverride': {
    'available-region-list': [
    'Region Four', 'Region One', 'Region Three', 'Region Two'],
    'assigned-region-dict': {
    'Region One': {
    'check-frontend-ip-list': ['99.99.99.7', '99.99.99.8'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    },
    'Region Two': {
    'check-frontend-ip-list': ['99.99.99.5', '99.99.99.6'],
    'nameserver-list': ['127.0.2.1', '127.0.2.2']
    }
    },
    },
    'three': {
    'available-region-list': [
    'Region Four', 'Region One', 'Region Three', 'Region Two'],
    'assigned-region-dict': {
    'Region Three': {
    'check-frontend-ip-list': ['127.0.3.1', '127.0.3.2'],
    'nameserver-list': []
    }
    }
    },
    'globalcheck': {
    'available-region-list': [
    'Region Four', 'Region One', 'Region Three', 'Region Two'],
    'assigned-region-dict': {
    'Region One': {
    'check-frontend-ip-list': ['99.99.99.3', '99.99.99.4'],
    'nameserver-list': ['127.0.1.1', '127.0.1.2']
    }
    },
    },
    'missed': {
    'available-region-list': [
    'Region Four', 'Region One', 'Region Three', 'Region Two'],
    'assigned-region-dict': {
    }
    },
    'partialmiss': {
    'available-region-list': [
    'Region Four', 'Region One', 'Region Three', 'Region Two'],
    'assigned-region-dict': {
    'Region Two': {
    'check-frontend-ip-list': [],
    'nameserver-list': ['127.0.2.1', '127.0.2.2']
    }
    }
    }
    }
    self.assertSlaveConnectionParameterDict()
    self.surykatka_dict['edge4'] = {
    2: {'expected_ini': """[SURYKATKA]
    INTERVAL = 120
    TIMEOUT = 4
    SQLITE = %(db_file)s
    URL =
    https://www.erp5.com/
    https://www.erp5.org/"""}
    }
    SQLITE = %(dbfile)
    NAMESERVER =
    127.0.4.1
    127.0.4.2
    @classmethod
    def getInstanceParameterDict(cls):
    return {
    'failure-amount': '5'
    URL =
    https://www.all.org/"""},
    }
    self.updateSurykatkaDict()
    def assertSurykatkaPromises(self):
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'report': 'http_query'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'status-code': '200'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'url': 'https://www.erp5.com/'")
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'json-file': '%s'" % (self.surykatka_dict[2]['json-file'],)
    )
    self.assertPromiseContent(
    'http-query-backend-promise.py',
    "'failure-amount': '5'"
    )
    self.assertPromiseContent(
    'http-query-backend-10-promise.py',
    "'report': 'http_query'")
    self.assertPromiseContent(
    'http-query-backend-10-promise.py',
    "'status-code': '200'")
    self.assertPromiseContent(
    'http-query-backend-10-promise.py',
    "'url': 'https://www.erp5.org/'")
    self.assertPromiseContent(
    'http-query-backend-10-promise.py',
    "'json-file': '%s'" % (self.surykatka_dict[2]['json-file'],)
    )
    self.assertPromiseContent(
    'http-query-backend-10-promise.py',
    "'failure-amount': '10'"
    )
    def requestEdgetestSlaves(self):
    self.requestEdgetestSlave(
    'backend',
    {'url': 'https://www.erp5.com/'},
    )
    self.requestEdgetestSlave(
    'backend-10',
    {'url': 'https://www.erp5.org/', 'failure-amount': '10'},
    )
    self.assertHttpQueryPromiseContent(
    'edge4',
    'all',
    """{ 'certificate-expiration-days': '15',
    'failure-amount': '2',
    'http-header-dict': '{}',
    'ip-list': '127.0.4.3 127.0.4.4',
    'json-file': '%s',
    'maximum-elapsed-time': '2',
    'report': 'http_query',
    'status-code': '200',
    'url': 'https://www.all.org/'}""" % (
    self.surykatka_dict['edge4'][2]['json-file'],))
    Markdown is supported
    0% or
    You are about to add 0 people to the discussion. Proceed with caution.
    Finish editing this message first!
    Please register or to comment
    GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7