Role for checking if local time is within required time interval (#167)

Implement check if local time is within safe hours

Role will fail if HyperCore server local time is not in specified time_interval.

Author: PolonaM

changelogs/fragments/check_local_time_role.yml

@@ -0,0 +1,3 @@
+---
+major_changes:
+  - Added a role for checking if local time is within required time interval. (https://github.com/ScaleComputing/HyperCoreAnsibleCollection/pull/167)

roles/check_local_time/README.md

@@ -0,0 +1,31 @@
+# check_local_time
+
+Role check_local_time can be used to:
+- check if local time in provided time zone is located within required time interval
+- ensure certain tasks/playbooks are executed only during allowed time interval. For example, HyperCore version upgrade might be allowed only outside of business hours.
+
+## Requirements
+
+- NA
+
+## Role Variables
+
+See [argument_specs.yml](../../roles/check_local_time/meta/argument_specs.yml).
+
+## Limitations
+
+- NA
+
+## Dependencies
+
+- NA
+
+## Example Playbook
+
+- NA
+
+## License
+
+GNU General Public License v3.0 or later
+
+See [LICENSE](../../LICENSE) to see the full text.

roles/check_local_time/files/check_local_time.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+# Copyright: (c) 2022, XLAB Steampunk <steampunk@xlab.si>
+#
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from __future__ import absolute_import, division, print_function
+from __future__ import annotations
+
+__metaclass__ = type
+
+import os
+import time
+import datetime
+import sys
+from typing import Tuple
+
+
+def get_local_time(time_zone: str) -> datetime.datetime:
+    # https://docs.python.org/3/library/time.html#time.tzset
+    # There should be no space in zone name.
+    # We have files like
+    #   /usr/share/zoneinfo/America/New_York
+    #   /usr/share/zoneinfo/America/North_Dakota/New_Salem
+    time_zone_nospace = time_zone.replace(" ", "_")
+
+    orig_tz = os.environ.get("TZ")
+    os.environ["TZ"] = time_zone_nospace
+    time.tzset()
+    # print(f"time tzname={time.tzname} timezone={time.timezone} altzone={time.altzone} daylight={time.daylight}")
+
+    local_struct_time = time.localtime()
+    local_time_str = time.strftime("%a %b %d %Y %H:%M:%S GMT%z", local_struct_time)
+    local_time = datetime.datetime.strptime(
+        local_time_str, "%a %b %d %Y %H:%M:%S GMT%z"
+    )
+
+    if orig_tz:
+        os.environ["TZ"] = orig_tz
+    else:
+        os.environ.pop("TZ")
+    time.tzset()
+
+    return local_time
+
+
+def get_time_interval(
+    time_interval: str,
+) -> Tuple[datetime.datetime, datetime.datetime]:
+    time_list = time_interval.split("-")
+    if len(time_list) != 2:
+        raise AssertionError("Required time interval not correctly formated")
+    start_time_str = time_list[0].strip()
+    end_time_str = time_list[1].strip()
+
+    # (datatime|time).strptime("22:00", "%H:%M") - does return something near year 1900
+    start_time = datetime.datetime.strptime(start_time_str, "%H:%M")
+    end_time = datetime.datetime.strptime(end_time_str, "%H:%M")
+
+    return (start_time, end_time)
+
+
+def is_local_time_in_time_interval(
+    local_time: datetime.datetime,
+    start_time: datetime.datetime,
+    end_time: datetime.datetime,
+) -> None:  # we have print()
+    if start_time < end_time:
+        # needs to be "print" to be able to read it from ansible.builin.script
+        print(start_time.time() <= local_time.time() < end_time.time())
+    else:  # Over midnight
+        print(
+            local_time.time() >= start_time.time()
+            or local_time.time() < end_time.time()
+        )
+
+
+def main(time_zone: str, time_interval: str) -> None:  # we have print()
+    local_time = get_local_time(time_zone)
+    start_time, end_time = get_time_interval(time_interval)
+    is_local_time_in_time_interval(local_time, start_time, end_time)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1], sys.argv[2])

roles/check_local_time/meta/argument_specs.yml

@@ -0,0 +1,19 @@
+---
+argument_specs:
+  main:
+    short_description: Check if local time meets the required time interval
+    description:
+      - Check if local time meets the required time interval
+    options:
+      time_zone:
+        description:
+          - Time zone for which to calculate if local time meets the required time interval
+          - Must be provided in a form 'Europe/Amsterdam'
+        required: true
+        type: str
+      time_interval:
+        description:
+          - Time interval in which local time must be located
+          - Must be provided in a form '22:00-6:15' or '7:30-12:36'
+        required: true
+        type: str

roles/check_local_time/tasks/main.yml

@@ -0,0 +1,33 @@
+---
+- name: Is executable python3
+  ansible.builtin.command: which python3
+  register: executable
+  changed_when: false  # to avoid ansible-lint error "no-changed-when: Commands should not change things if nothing needs doing."
+  ignore_errors: true  # if there is no python3, the shell will fail
+
+- name: Is executable python
+  ansible.builtin.command: which python
+  register: executable_python
+  changed_when: false  # to avoid ansible-lint error "no-changed-when: Commands should not change things if nothing needs doing."
+  ignore_errors: true  # if there is no python, the shell will fail
+
+- name: If not python3, then set executable to python
+  ansible.builtin.set_fact: executable="{{ executable_python }}"
+  when: not executable.stdout_lines
+
+- name: Check if local time is in time interval (run check_local_time.py)
+  ansible.builtin.script:
+    executable: "{{ executable.stdout_lines[0] }}"
+    cmd: check_local_time.py "{{ time_zone }}" "{{ time_interval }}"
+  register: local_time_output
+
+- name: Assert that local time is in time interval
+  ansible.builtin.assert:
+    fail_msg: "Local time for time zone {{ time_zone }} is not in required time interval {{ time_interval }}"
+    success_msg: "Local time for time zone {{ time_zone }} is in required time interval {{ time_interval }}"
+    that:
+      - local_time_output.stdout_lines[0] == "True"
+  register: result
+
+- name: Set fact to use in tests
+  ansible.builtin.set_fact: local_time_msg="{{ result.msg }}"

tests/integration/targets/role_check_local_time/tasks/main.yml

@@ -0,0 +1,33 @@
+---
+- environment:
+    SC_HOST: "{{ sc_host }}"
+    SC_USERNAME: "{{ sc_username }}"
+    SC_PASSWORD: "{{ sc_password }}"
+    SC_TIMEOUT: "{{ sc_timeout }}"
+
+  block:
+    - name: Check that local time meets required time interval
+      ansible.builtin.include_role:
+        name: scale_computing.hypercore.check_local_time
+      vars:
+        time_zone: "{{ ansible_date_time.tz }}"
+        time_interval: "{{ ansible_date_time.hour }}:00-{{ ansible_date_time.hour }}:59"
+    
+    # it can fail when run near x:59
+    - ansible.builtin.assert:
+        that:
+          - "'Local time for time zone {{ ansible_date_time.tz }} is in required time interval {{ ansible_date_time.hour }}:00-{{ ansible_date_time.hour }}:59' in local_time_msg" 
+
+    - name: Check that local time doesn't meet required time interval
+      ansible.builtin.include_role:
+        name: scale_computing.hypercore.check_local_time
+        apply:
+          ignore_errors: True
+      vars:
+        time_zone: "{{ ansible_date_time.tz }}"
+        time_interval: "{{ ansible_date_time.hour }}:00-{{ ansible_date_time.hour }}:01"
+
+    # it can fail when run near x:00
+    - ansible.builtin.assert:
+        that:
+          - "'Local time for time zone {{ ansible_date_time.tz }} is not in required time interval {{ ansible_date_time.hour }}:00-{{ ansible_date_time.hour }}:01' in local_time_msg" 

tests/unit/plugins/module_utils/test_check_local_time.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+# # Copyright: (c) 2022, XLAB Steampunk <steampunk@xlab.si>
+#
+# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
+
+from __future__ import absolute_import, division, print_function
+
+__metaclass__ = type
+
+import sys
+import pytest
+import datetime
+
+from ansible_collections.scale_computing.hypercore.roles.check_local_time.files import (
+    check_local_time,
+)
+
+# from ansible_collections.scale_computing.hypercore.plugins.module_utils import (
+#     check_local_time,
+# )
+
+from ansible_collections.scale_computing.hypercore.plugins.module_utils.utils import (
+    MIN_PYTHON_VERSION,
+)
+
+pytestmark = pytest.mark.skipif(
+    sys.version_info < MIN_PYTHON_VERSION,
+    reason=f"requires python{MIN_PYTHON_VERSION[0]}.{MIN_PYTHON_VERSION[1]} or higher",
+)
+
+
+class TestCheckLocalTime:
+    def test_get_local_time(self):
+        local_time = check_local_time.get_local_time("Europe/Ljubljana")
+        assert type(local_time) == datetime.datetime
+
+    def test_get_time_interval(self):
+        start_time, end_time = check_local_time.get_time_interval("22:31-4:45")
+        start_time_str = datetime.datetime.strftime(start_time, "%H:%M")
+        end_time_str = datetime.datetime.strftime(end_time, "%H:%M")
+
+        assert start_time_str == "22:31"
+        assert end_time_str == "04:45"
+
+    @pytest.mark.parametrize(
+        "time_interval, expected_result",
+        [
+            ("22:30-1:30", "False"),
+            ("6:30-08:30", "False"),
+            ("12:30-13:00", "True"),
+            ("1:00-12:30", "False"),
+            ("1:00-12:31", "True"),
+            ("22:00-12:30", "False"),
+            ("22:00-12:31", "True"),
+        ],
+    )
+    def test_is_local_time_in_time_interval(
+        self, time_interval, expected_result, capfd
+    ):
+        local_time = datetime.datetime.now()
+        local_time_constant = local_time.replace(hour=12, minute=30)
+
+        start_time, end_time = check_local_time.get_time_interval(time_interval)
+        check_local_time.is_local_time_in_time_interval(
+            local_time_constant, start_time, end_time
+        )
+        result, err = capfd.readouterr()
+
+        assert result.strip() == expected_result  # strip removes "\n"
+
+    @pytest.mark.parametrize(
+        "time_interval, expected_result",
+        [
+            ("22:30-1:30", "False"),
+            ("6:30-08:30", "False"),
+            ("12:30-13:00", "True"),
+            ("1:00-12:30", "False"),
+            ("1:00-12:31", "True"),
+            ("22:00-12:30", "False"),
+            ("22:00-12:31", "True"),
+        ],
+    )
+    def test_main(self, mocker, time_interval, expected_result, capfd):
+        local_time = datetime.datetime.now()
+        local_time_constant = local_time.replace(hour=12, minute=30)
+        mocker.patch(
+            "ansible_collections.scale_computing.hypercore.roles.check_local_time.files.check_local_time.get_local_time"
+        ).return_value = local_time_constant
+
+        check_local_time.main("Europe/Ljubljana", time_interval)
+        result, err = capfd.readouterr()
+
+        assert result.strip() == expected_result