cicada 0.6.0__tar.gz → 0.8.2__tar.gz

{cicada-0.6.0 → cicada-0.8.2}/PKG-INFO

@@ -1,14 +1,26 @@
 Metadata-Version: 2.1
 Name: cicada
-Version: 0.6.0
+Version: 0.8.2
 Summary: Lightweight, agent-based, distributed scheduler
 Home-page: https://github.com/transferwise/cicada
 Author: Wise
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3 :: Only
 Description-Content-Type: text/markdown
-Provides-Extra: dev
 License-File: LICENSE
+Requires-Dist: psycopg2-binary==2.9.*
+Requires-Dist: pyyaml==6.0.*
+Requires-Dist: croniter==2.0.*
+Requires-Dist: tabulate==0.9.*
+Requires-Dist: slack-sdk==3.30.*
+Requires-Dist: backoff==2.2.*
+Provides-Extra: dev
+Requires-Dist: pytest==8.2.*; extra == "dev"
+Requires-Dist: pytest-cov==5.0.*; extra == "dev"
+Requires-Dist: pytest-mock==3.14.*; extra == "dev"
+Requires-Dist: black==24.4.*; extra == "dev"
+Requires-Dist: flake8==7.1.*; extra == "dev"
+Requires-Dist: freezegun==1.5.*; extra == "dev"
 
 # Cicada scheduler
 

{cicada-0.6.0 → cicada-0.8.2}/cicada/cli.py

@@ -3,6 +3,7 @@
 import argparse
 import sys
 import inspect
+from pkg_resources import get_distribution
 
 from cicada.lib import utils
 
@@ -15,6 +16,8 @@ from cicada.commands import exec_schedule
 from cicada.commands import spread_schedules
 from cicada.commands import archive_schedule_log
 from cicada.commands import ping_slack
+from cicada.commands import list_schedules
+from cicada.commands import delete_schedule
 
 
 @utils.named_exception_handler("Cicada")
@@ -32,6 +35,9 @@ class Cicada:
             "spread_schedules",
             "archive_schedule_log",
             "ping_slack",
+            "list_schedule_ids",
+            "delete_schedule",
+            "version",
         ]
 
         parser = argparse.ArgumentParser(
@@ -239,6 +245,39 @@ class Cicada:
         args = parser.parse_args(sys.argv[2:])
         ping_slack.main(args.text)
 
+    @staticmethod
+    def list_schedule_ids():
+        """List schedule ids of all schedules"""
+        parser = argparse.ArgumentParser(
+            allow_abbrev=False,
+            add_help=True,
+            prog=inspect.stack()[0][3],
+            description="List schedule ids of all schedules",
+        )
+        if len(sys.argv) >= 3:
+            parser.print_help(sys.stdout)
+            sys.exit(0)
+        list_schedules.main()
+
+    @staticmethod
+    def delete_schedule():
+        """Delete a schedule using schedule_id"""
+        parser = argparse.ArgumentParser(
+            allow_abbrev=False,
+            add_help=True,
+            prog=inspect.stack()[0][3],
+            description="Delete a schedule using schedule_id",
+        )
+        parser.add_argument("--schedule_id", type=str, required=True, help="Id of the schedule")
+        # now that we're inside a subcommand, ignore the first TWO args
+        args = parser.parse_args(sys.argv[2:])
+        delete_schedule.main(args.schedule_id)
+
+    @staticmethod
+    def version():
+        """Return version of cicada package"""
+        print(get_distribution("cicada").version)
+
 
 def main():
     """Cicada agent CLI."""

cicada-0.8.2/cicada/commands/delete_schedule.py

@@ -0,0 +1,22 @@
+"""Delete a schedule using schedule_id."""
+
+import sys
+
+from tabulate import tabulate
+
+from cicada.lib import postgres
+from cicada.lib import scheduler
+from cicada.lib import utils
+
+
+@utils.named_exception_handler("delete_schedule")
+def main(schedule_id, dbname=None):
+    """Delete a schedule using schedule_id."""
+
+    db_conn = postgres.db_cicada(dbname)
+    db_cur = db_conn.cursor()
+    scheduler.delete_schedule(db_cur, str(schedule_id))
+    db_cur.close()
+    db_conn.close()
+
+    print("schedule_id '" + str(schedule_id) + "' is deleted!")

{cicada-0.6.0 → cicada-0.8.2}/cicada/commands/exec_schedule.py

@@ -197,7 +197,6 @@ def main(schedule_id, dbname=None):
                         db_conn = postgres.db_cicada(dbname)
                         db_cur = db_conn.cursor()
                         if get_abort_running(db_cur, schedule_id):
-
                             # Terminate main process
                             returncode = -15
                             error_detail = "Cicada abort_running"

cicada-0.8.2/cicada/commands/list_schedules.py

@@ -0,0 +1,19 @@
+"""List all schedule ID's."""
+
+from tabulate import tabulate
+
+from cicada.lib import postgres
+from cicada.lib import scheduler
+from cicada.lib import utils
+
+
+@utils.named_exception_handler("list_schedule_ids")
+def main(dbname=None):
+    """Show all Cicada schedule ID's."""
+    db_conn = postgres.db_cicada(dbname)
+    db_cur = db_conn.cursor()
+    obj_schedules = scheduler.get_all_schedule_ids(db_cur)
+    db_cur.close()
+    db_conn.close()
+    print("")
+    print(tabulate(obj_schedules, headers=["Server ID", "Schedule ID", "Description"]))

{cicada-0.6.0 → cicada-0.8.2}/cicada/commands/spread_schedules.py

@@ -93,7 +93,6 @@ def main(spread_details, dbname=None):
     last_week_schedules_by_load = get_last_week_schedules_by_load(db_cur, from_server_ids)
 
     for schedule_id in last_week_schedules_by_load:
-
         current_schedule_details = scheduler.get_schedule_details(db_cur, schedule_id)
         new_schedule_details = current_schedule_details.copy()
         new_schedule_details["server_id"] = valid_target_servers[next_enabled_server]

{cicada-0.6.0 → cicada-0.8.2}/cicada/commands/upsert_schedule.py

@@ -28,7 +28,6 @@ def main(schedule_details, dbname=None):
     current_schedule_details = scheduler.get_schedule_details(db_cur, schedule_details["schedule_id"])
 
     if not current_schedule_details:
-
         if schedule_details["interval_mask"] is None:
             print("ERROR: interval_mask is required for new schedule")
             sys.exit(1)

{cicada-0.6.0 → cicada-0.8.2}/cicada/lib/postgres.py

@@ -1,4 +1,5 @@
 """Backend PostgreSQL database library"""
+
 # 2015-07-01 Louis Pieterse
 
 import psycopg2
@@ -18,7 +19,7 @@ def db_cicada(dbname=None):
     user = definitions["db_cicada"]["user"]
     password = definitions["db_cicada"]["password"]
 
-    conn = psycopg2.connect(host=host, port=port, dbname=dbname, user=user, password=password)
+    conn = psycopg2.connect(host=host, port=port, dbname=dbname, user=user, password=password, sslmode="prefer")
     conn.autocommit = True
 
     return conn

{cicada-0.6.0 → cicada-0.8.2}/cicada/lib/scheduler.py

@@ -25,7 +25,6 @@ def get_host_details():
         hostname = hostname[: hostname.find(".")]
 
     fqdn = socket.getfqdn()
-
     ip4_address = socket.gethostbyname(fqdn)
 
     host_details = {"hostname": hostname, "fqdn": fqdn, "ip4_address": ip4_address}
@@ -348,3 +347,17 @@ def get_all_schedules(db_cur, server_id, is_async):
                 obj_schedules.append(schedule_id)
 
     return obj_schedules
+
+
+def get_all_schedule_ids(db_cur):
+    sqlquery = "SELECT server_id, schedule_id, schedule_description from schedules"
+    db_cur.execute(sqlquery)
+    cur_schedules = db_cur
+
+    schedule_ids = cur_schedules.fetchall()
+    return schedule_ids
+
+
+def delete_schedule(db_cur, schedule_id):
+    sqlquery = f"DELETE from schedules WHERE schedule_id = '{schedule_id}'"
+    db_cur.execute(sqlquery)

{cicada-0.6.0 → cicada-0.8.2}/cicada.egg-info/PKG-INFO

@@ -1,14 +1,26 @@
 Metadata-Version: 2.1
 Name: cicada
-Version: 0.6.0
+Version: 0.8.2
 Summary: Lightweight, agent-based, distributed scheduler
 Home-page: https://github.com/transferwise/cicada
 Author: Wise
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3 :: Only
 Description-Content-Type: text/markdown
-Provides-Extra: dev
 License-File: LICENSE
+Requires-Dist: psycopg2-binary==2.9.*
+Requires-Dist: pyyaml==6.0.*
+Requires-Dist: croniter==2.0.*
+Requires-Dist: tabulate==0.9.*
+Requires-Dist: slack-sdk==3.30.*
+Requires-Dist: backoff==2.2.*
+Provides-Extra: dev
+Requires-Dist: pytest==8.2.*; extra == "dev"
+Requires-Dist: pytest-cov==5.0.*; extra == "dev"
+Requires-Dist: pytest-mock==3.14.*; extra == "dev"
+Requires-Dist: black==24.4.*; extra == "dev"
+Requires-Dist: flake8==7.1.*; extra == "dev"
+Requires-Dist: freezegun==1.5.*; extra == "dev"
 
 # Cicada scheduler
 

{cicada-0.6.0 → cicada-0.8.2}/cicada.egg-info/SOURCES.txt

@@ -12,8 +12,10 @@ cicada.egg-info/requires.txt
 cicada.egg-info/top_level.txt
 cicada/commands/__init__.py
 cicada/commands/archive_schedule_log.py
+cicada/commands/delete_schedule.py
 cicada/commands/exec_schedule.py
 cicada/commands/exec_server_schedules.py
+cicada/commands/list_schedules.py
 cicada/commands/list_server_schedules.py
 cicada/commands/ping_slack.py
 cicada/commands/register_server.py
@@ -23,4 +25,10 @@ cicada/commands/upsert_schedule.py
 cicada/lib/__init__.py
 cicada/lib/postgres.py
 cicada/lib/scheduler.py
-cicada/lib/utils.py
+cicada/lib/utils.py
+tests/test_functional_archive_logs.py
+tests/test_functional_cli_entrypoint.py
+tests/test_functional_main.py
+tests/test_functional_spread_schedules.py
+tests/test_lib_postgres.py
+tests/test_lib_scheduler.py

cicada-0.8.2/cicada.egg-info/requires.txt

@@ -0,0 +1,14 @@
+psycopg2-binary==2.9.*
+pyyaml==6.0.*
+croniter==2.0.*
+tabulate==0.9.*
+slack-sdk==3.30.*
+backoff==2.2.*
+
+[dev]
+pytest==8.2.*
+pytest-cov==5.0.*
+pytest-mock==3.14.*
+black==24.4.*
+flake8==7.1.*
+freezegun==1.5.*

{cicada-0.6.0 → cicada-0.8.2}/setup.py

@@ -7,7 +7,7 @@ with open("README.md") as f:
 
 setup(
     name="cicada",
-    version="0.6.0",
+    version="0.8.2",
     description="Lightweight, agent-based, distributed scheduler",
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -18,21 +18,21 @@ setup(
         "Programming Language :: Python :: 3 :: Only",
     ],
     install_requires=[
-        "psycopg2-binary==2.9.5",
-        "pyyaml==6.0",
-        "croniter==1.3",
-        "tabulate==0.9",
-        "slack-sdk==3.19",
-        "backoff==2.2",
+        "psycopg2-binary==2.9.*",
+        "pyyaml==6.0.*",
+        "croniter==2.0.*",
+        "tabulate==0.9.*",
+        "slack-sdk==3.30.*",
+        "backoff==2.2.*",
     ],
     extras_require={
         "dev": [
-            "pytest==7.3",
-            "pytest-cov==4.0",
-            "pytest-mock==3.10",
-            "black==22.12",
-            "flake8==6.0",
-            "freezegun==1.2",
+            "pytest==8.2.*",
+            "pytest-cov==5.0.*",
+            "pytest-mock==3.14.*",
+            "black==24.4.*",
+            "flake8==7.1.*",
+            "freezegun==1.5.*",
         ]
     },
     entry_points={"console_scripts": ["cicada=cicada.cli:main"]},

cicada-0.8.2/tests/test_functional_archive_logs.py

@@ -0,0 +1,200 @@
+"""
+    test_functional_archive_logs.py
+    Test archiving schedule_log entries into schedule_log_historical
+"""
+
+from unittest import result
+import pytest
+import os
+import datetime
+import psycopg2
+
+from cicada.commands import archive_schedule_log
+
+
+@pytest.fixture(scope="session", autouse=True)
+def get_env_vars():
+    """get_env_vars"""
+
+    pytest.cicada_home = os.environ.get("CICADA_HOME")
+
+    pytest.db_host = os.environ.get("DB_POSTGRES_HOST")
+    pytest.db_port = os.environ.get("DB_POSTGRES_PORT")
+    pytest.db_user = os.environ.get("DB_POSTGRES_USER")
+    pytest.db_pass = os.environ.get("DB_POSTGRES_PASS")
+
+    pytest.db_test = f"pytest_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S_%f')}"
+
+
+@pytest.fixture()
+def db_setup(get_env_vars):
+    """db_setup"""
+
+    # Create the test_db
+    pg_conn = psycopg2.connect(
+        host=pytest.db_host,
+        port=pytest.db_port,
+        user=pytest.db_user,
+        password=pytest.db_pass,
+        database="postgres",
+    )
+    pg_conn.autocommit = True
+    pg_cur = pg_conn.cursor()
+    pg_cur.execute(f"CREATE DATABASE {pytest.db_test}")
+
+    # Create test_db structure
+    test_conn = psycopg2.connect(
+        host=pytest.db_host,
+        port=pytest.db_port,
+        user=pytest.db_user,
+        password=pytest.db_pass,
+        database=pytest.db_test,
+    )
+    test_conn.autocommit = True
+    test_cur = test_conn.cursor()
+    test_cur.execute(open(f"{pytest.cicada_home}/setup/schema.sql", "r", encoding="utf-8").read())
+    test_cur.close()
+    test_conn.close()
+
+
+def query_test_db(query):
+    """Run and SQL query in a postgres database"""
+    rows = []
+    conn = psycopg2.connect(
+        host=pytest.db_host,
+        port=pytest.db_port,
+        user=pytest.db_user,
+        password=pytest.db_pass,
+        database=pytest.db_test,
+    )
+    conn.set_session(readonly=False, autocommit=True)
+
+    cur = conn.cursor()
+
+    cur.execute(query)
+
+    if cur.rowcount > 0 and cur.description:
+        rows = cur.fetchall()
+
+    cur.close()
+    conn.close()
+    return rows
+
+
+def test_test_db_setup(db_setup):
+    """test_test_db_setup"""
+    query_result = query_test_db("SELECT 1")
+
+    assert query_result == [(1,)]
+
+
+def test_create_dummy_servers():
+    """test_create_dummy_servers"""
+    query_test_db(
+        """
+        INSERT INTO servers
+            (server_id, hostname, fqdn, ip4_address, is_enabled)
+        VALUES
+            (1, '1', '1', '192.168.0.1', 1)
+        ;
+        """
+    )
+
+    results = query_test_db(f"SELECT count(*) FROM servers WHERE is_enabled=1")[0][0]
+
+    assert results == 1
+
+
+def test_create_dummy_schedules():
+    """test_create_dummy_schedules"""
+    query_test_db(
+        """
+        INSERT INTO schedules
+            (server_id, schedule_id, interval_mask, exec_command, is_enabled, is_running)
+        VALUES
+             (1, '1-1', '* * * * *', '1-1', 1, 0)
+            ,(1, '1-2', '* * * * *', '1-2', 1, 0)
+            ,(1, '1-3', '* * * * *', '1-3', 1, 1)
+            ,(1, '1-4', '* * * * *', '1-4', 1, 0)
+        ;
+        """
+    )
+
+    results = query_test_db(f"SELECT count(*) FROM schedules WHERE is_enabled=1")[0][0]
+
+    assert results == 4
+
+
+def test_create_dummy_schedule_logs():
+    """test_create_dummy_schedule_logs"""
+    query_test_db(
+        """
+        INSERT INTO schedule_log
+            (server_id, schedule_id, full_command, start_time, end_time, returncode)
+        VALUES
+             (1, '1-1', '1-1', '2022-01-01 01:00:00', '2022-01-01 02:00:00' , 0)
+            ,(1, '1-1', '1-1', '2022-01-01 03:00:00', '2022-01-01 04:00:00' , 0)
+            ,(1, '1-1', '1-1', '2022-01-01 05:00:00', '2022-01-01 06:00:00' , 0)
+            ,(1, '1-1', '1-1', '2022-01-01 07:00:00', '2022-01-01 08:00:00' , 0)
+            ,(1, '1-1', '1-1', '2022-01-01 09:00:00', '2022-01-01 10:00:00' , 0)
+            ,(1, '1-2', '1-2', '2022-01-01 01:00:00', null , null)
+            ,(1, '1-2', '1-2', '2022-01-01 03:00:00', null , null)
+            ,(1, '1-2', '1-2', '2022-01-01 04:00:00', null , null)
+            ,(1, '1-2', '1-2', '2022-01-01 07:00:00', null , null)
+            ,(1, '1-2', '1-2', '2022-01-01 09:00:00', null , null)
+            ,(1, '1-3', '1-3', '2022-01-01 01:00:00', null , null)
+            ,(1, '1-3', '1-3', '2022-01-01 03:00:00', null , null)
+            ,(1, '1-3', '1-3', '2022-01-01 05:00:00', null , null)
+            ,(1, '1-3', '1-3', '2022-01-01 07:00:00', null , null)
+            ,(1, '1-3', '1-3', '2022-01-01 09:00:00', null , null)
+        ;
+        """
+    )
+
+    results = query_test_db(f"SELECT count(*) FROM schedule_log")[0][0]
+
+    assert results == 15
+
+
+def test_archive_schedules():
+    """test_archive_schedules"""
+    archive_schedule_log.main(1, pytest.db_test)
+
+    result = query_test_db(
+        f"SELECT (SELECT count(*) FROM schedule_log) || ',' || (SELECT count(*) from schedule_log_historical)"
+    )[0][0]
+
+    assert result == "2,13"
+
+
+def test_archive_schedule_keep_correct_schedules():
+    """test_archive_schedule_keep_correct_schedules"""
+
+    result = query_test_db(f"SELECT schedule_id, start_time, end_time, returncode FROM schedule_log")
+
+    assert result == [
+        (
+            "1-1",
+            datetime.datetime(2022, 1, 1, 9, 0),
+            datetime.datetime(2022, 1, 1, 10, 0),
+            0,
+        ),
+        ("1-3", datetime.datetime(2022, 1, 1, 9, 0), None, None),
+    ]
+
+
+def test_db_teardown():
+    """test_db_teardown"""
+    pg_conn = psycopg2.connect(
+        host=pytest.db_host,
+        port=pytest.db_port,
+        user=pytest.db_user,
+        password=pytest.db_pass,
+        database="postgres",
+    )
+    pg_conn.autocommit = True
+    pg_cur = pg_conn.cursor()
+
+    pg_cur.execute(f"DROP DATABASE IF EXISTS {pytest.db_test}")
+    pg_cur.close()
+    pg_conn.close()