pyegeria 0.8.4.9__py3-none-any.whl → 0.8.4.11__py3-none-any.whl

examples/widgets/ops/monitor_gov_eng_status.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Unit tests for the Utils helper functions using the Pytest framework.
+
+
+A simple status display for Governance Actions
+"""
+import argparse
+import json
+import os
+import time
+
+from rich import box
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.table import Table
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+from pyegeria.server_operations import ServerOps
+
+EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
+EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
+EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
+EGERIA_VIEW_SERVER = os.environ.get("VIEW_SERVER", "view-server")
+EGERIA_VIEW_SERVER_URL = os.environ.get(
+    "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
+)
+EGERIA_INTEGRATION_DAEMON = os.environ.get(
+    "EGERIA_INTEGRATION_DAEMON", "integration-daemon"
+)
+EGERIA_ENGINE_HOST = os.environ.get("EGERIA_ENGINE_HOST", "engine-host")
+EGERIA_ENGINE_HOST_URL = os.environ.get(
+    "EGERIA_ENGINE_HOST_URL", "https://localhost:9443"
+)
+EGERIA_ADMIN_USER = os.environ.get("EGERIA_ADMIN_USER", "garygeeke")
+EGERIA_ADMIN_PASSWORD = os.environ.get("EGERIA_ADMIN_PASSWORD", "secret")
+EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+EGERIA_JUPYTER = bool(os.environ.get("EGERIA_JUPYTER", "False"))
+EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
+
+
+disable_ssl_warnings = True
+
+
+def display_gov_eng_status(
+    server: str,
+    url: str,
+    username: str,
+    user_pass: str,
+    paging: bool,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    console = Console(width=EGERIA_WIDTH)
+    server_name = server
+    s_client = ServerOps(server_name, url, username, user_pass)
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Governance Engine Status @ {time.asctime()}",
+            style="bold white on black",
+            row_styles=["bold white on black"],
+            header_style="white on dark_blue",
+            title_style="bold white on black",
+            caption_style="white on black",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"Server: '{server_name}' running on {url}",
+            expand=True,
+        )
+        # table.footer: f"Server {server_name} on Platform {good_platform1_url}"
+        table.add_column("Gov Engine")
+        table.add_column("Gov Engine Type")
+        table.add_column("Gov Engine Desc")
+        table.add_column("Engine Status")
+        table.add_column("Request Types")
+
+        gov_eng_status = s_client.get_governance_engine_summaries()
+        sorted_gov_eng_status = sorted(
+            gov_eng_status, key=lambda k: k.get("governanceEngineName", " ")
+        )
+        for engine in sorted_gov_eng_status:
+            gov_eng = engine["governanceEngineName"]
+            eng_type = engine.get("governanceEngineTypeName", " ")
+
+            eng_desc = engine.get("governanceEngineDescription", " ")
+            eng_req_types = engine.get("governanceRequestTypes", " ")
+            eng_req_type_md = " "
+            if type(eng_req_types) is list:
+                for i in eng_req_types:
+                    eng_req_type_md += f"* {i}\n"
+                eng_req_type_out = Markdown(eng_req_type_md)
+            else:
+                eng_req_type_out = " "
+            status = engine["governanceEngineStatus"]
+            if status in ("RUNNING"):
+                eng_status = f"[green]{status}"
+            elif status in ("FAILED"):
+                eng_status = f"[red]{status}"
+            else:
+                eng_status = f"[yellow]{status}"
+
+            table.add_row(gov_eng, eng_type, eng_desc, eng_status, eng_req_type_out)
+
+        table.caption = f"Server {server_name} running on {url}"
+        return table
+
+    try:
+        if paging is True:
+            console = Console(width=width, force_terminal=not jupyter)
+            with console.pager():
+                console.print(generate_table())
+        else:
+            with Live(
+                generate_table(),
+                refresh_per_second=1,
+                screen=True,
+                vertical_overflow="visible",
+            ) as live:
+                while True:
+                    time.sleep(2)
+                    live.update(generate_table())
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        console.print_exception(show_locals=True)
+
+    except KeyboardInterrupt:
+        pass
+
+    finally:
+        s_client.close_session()
+
+
+def main_live():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--server", help="Name of the server to display status for")
+    parser.add_argument("--url", help="URL Platform to connect to")
+    parser.add_argument("--userid", help="User Id")
+    parser.add_argument("--password", help="User Password")
+    parser.add_argument("--paging", help="Paging")
+    args = parser.parse_args()
+
+    server = args.server if args.server is not None else EGERIA_ENGINE_HOST
+    url = args.url if args.url is not None else EGERIA_ENGINE_HOST_URL
+    userid = args.userid if args.userid is not None else EGERIA_USER
+    user_pass = args.password if args.password is not None else EGERIA_USER_PASSWORD
+    paging = args.paging if args.paging is not None else False
+    display_gov_eng_status(server, url, userid, user_pass, paging)
+
+
+def main_paging():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--server", help="Name of the server to display status for")
+    parser.add_argument("--url", help="URL Platform to connect to")
+    parser.add_argument("--userid", help="User Id")
+    parser.add_argument("--password", help="User Password")
+    args = parser.parse_args()
+
+    server = args.server if args.server is not None else EGERIA_ENGINE_HOST
+    url = args.url if args.url is not None else EGERIA_ENGINE_HOST_URL
+    userid = args.userid if args.userid is not None else EGERIA_USER
+    user_pass = args.password if args.password is not None else EGERIA_USER_PASSWORD
+
+    display_gov_eng_status(
+        server=server, url=url, username=userid, user_pass=user_pass, paging=True
+    )
+
+
+if __name__ == "__main__":
+    main_live()
+
+if __name__ == "__main_paging__":
+    main_paging()

examples/widgets/ops/monitor_integ_daemon_status.py

@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+A simple status display for the Integration Daemon.
+
+
+"""
+import argparse
+import os
+import time
+
+from rich import box
+from rich.console import Console
+from rich.live import Live
+from rich.table import Table
+
+from pyegeria import ServerOps, AutomatedCuration
+from pyegeria._exceptions import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+
+EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
+EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
+EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
+EGERIA_VIEW_SERVER = os.environ.get("VIEW_SERVER", "view-server")
+EGERIA_VIEW_SERVER_URL = os.environ.get(
+    "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
+)
+EGERIA_INTEGRATION_DAEMON = os.environ.get("INTEGRATION_DAEMON", "integration-daemon")
+EGERIA_INTEGRATION_DAEMON_URL = os.environ.get(
+    "EGERIA_INTEGRATION_DAEMON_URL", "https://localhost:9443"
+)
+EGERIA_ADMIN_USER = os.environ.get("ADMIN_USER", "garygeeke")
+EGERIA_ADMIN_PASSWORD = os.environ.get("ADMIN_PASSWORD", "secret")
+EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+EGERIA_JUPYTER = bool(os.environ.get("EGERIA_JUPYTER", "False"))
+EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
+
+disable_ssl_warnings = True
+
+
+def display_integration_daemon_status(
+    integ_server: str,
+    integ_url: str,
+    view_server: str,
+    view_url: str,
+    user: str,
+    user_pass: str,
+    paging: bool,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+    sort: bool = True,
+):
+    s_client = ServerOps(integ_server, integ_url, user)
+    a_client = AutomatedCuration(view_server, view_url, user, user_pass)
+    token = a_client.create_egeria_bearer_token()
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Integration Daemon Status @ {time.asctime()}",
+            style="bold white on black",
+            row_styles=["bold white on black"],
+            header_style="white on dark_blue",
+            title_style="bold white on black",
+            caption_style="white on black",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"Integration Daemon Status for Server '{integ_server}' @ Platform - {integ_url}",
+            expand=True,
+        )
+        table.add_column("Connector Name", min_width=15)
+        table.add_column("Status", max_width=6)
+
+        table.add_column("Last Refresh Time", min_width=12)
+        table.add_column("Min Refresh (mins)", max_width=6)
+        table.add_column("Target Element", min_width=20)
+        table.add_column("Exception Message", min_width=10)
+
+        daemon_status = s_client.get_integration_daemon_status()
+
+        reports = daemon_status["integrationConnectorReports"]
+        if sort is True:
+            connector_reports = sorted(
+                reports, key=lambda x: x.get("connectorName", "---")
+            )
+        else:
+            connector_reports = reports
+
+        for connector in connector_reports:
+            connector_name = connector.get("connectorName", "---")
+            connector_status = connector.get("connectorStatus", "---")
+            connector_guid = connector.get("connectorGUID", "---")
+            last_refresh_time = connector.get("lastRefreshTime", "---")[:-10]
+            refresh_interval = str(connector.get("minMinutesBetweenRefresh", "---"))
+            exception_msg = " "
+            if connector_guid != "---":
+                targets = a_client.get_catalog_targets(connector_guid)
+                tgt_tab = Table()
+                tgt_tab.add_column("Target")
+                tgt_tab.add_column("UniqueName")
+                tgt_tab.add_column("Relationship GUID", no_wrap=True)
+
+                if type(targets) == list:
+                    targets_md = True
+                    for target in targets:
+                        t_name = target["catalogTargetName"]
+                        # t_sync = target["permittedSynchronization"]
+                        t_unique_name = target["catalogTargetElement"]["uniqueName"]
+                        t_rel_guid = target["relationshipGUID"]
+                        # targets_m += f"* Target Name: __{t_name}__\n* Sync: {t_sync}\n* Unique Name: {t_unique_name}\n\n"
+                        tgt_tab.add_row(t_name, t_unique_name, t_rel_guid)
+                    # targets_md = Markdown(targets_m)
+                else:
+                    targets_md = False
+            else:
+                targets_md = False
+            if targets_md is False:
+                targets_out = ""
+            else:
+                targets_out = tgt_tab
+
+            if connector_status in ("RUNNING", "REFRESHING", "WAITING"):
+                connector_status = f"[green]{connector_status}"
+            elif connector_status in ("INITIALIZE FAILED", "CONFIG_FAILED", "FAILED"):
+                connector_status = f"[red]{connector_status}"
+            else:
+                connector_status = f"[yellow]{connector_status}"
+
+            table.add_row(
+                connector_name,
+                connector_status,
+                last_refresh_time,
+                refresh_interval,
+                targets_out,
+                exception_msg,
+            )
+        return table
+
+    try:
+        if paging is True:
+            console = Console(width=width, force_terminal=not jupyter)
+            with console.pager():
+                console.print(generate_table())
+        else:
+            with Live(
+                generate_table(),
+                refresh_per_second=1,
+                screen=True,
+                vertical_overflow="visible",
+            ) as live:
+                while True:
+                    time.sleep(2)
+                    live.update(generate_table())
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+
+    except KeyboardInterrupt:
+        pass
+
+    finally:
+        s_client.close_session()
+        a_client.close_session()
+
+
+def main_live():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--integ_server", help="Name of the integration server to display status for"
+    )
+    parser.add_argument("--integ_url", help="URL Platform to connect to")
+    parser.add_argument("--view_server", help="Name of the view server to use")
+    parser.add_argument("--view_url", help="view server URL Platform to connect to")
+    parser.add_argument("--userid", help="User Id")
+    parser.add_argument("--password", help="User Password")
+    args = parser.parse_args()
+
+    integ_server = (
+        args.integ_server
+        if args.integ_server is not None
+        else EGERIA_INTEGRATION_DAEMON
+    )
+    integ_url = (
+        args.integ_url if args.integ_url is not None else EGERIA_INTEGRATION_DAEMON_URL
+    )
+    view_server = (
+        args.view_server if args.view_server is not None else EGERIA_VIEW_SERVER
+    )
+    view_url = args.view_url if args.view_url is not None else EGERIA_VIEW_SERVER_URL
+    userid = args.userid if args.userid is not None else EGERIA_USER
+    user_pass = args.password if args.password is not None else EGERIA_USER_PASSWORD
+    display_integration_daemon_status(
+        integ_server=integ_server,
+        integ_url=integ_url,
+        view_server=view_server,
+        view_url=view_url,
+        user=userid,
+        user_pass=user_pass,
+        paging=False,
+    )
+
+
+def main_paging():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--integ_server", help="Name of the integration server to display status for"
+    )
+    parser.add_argument("--integ_url", help="URL Platform to connect to")
+    parser.add_argument("--view_server", help="Name of the view server to use")
+    parser.add_argument("--view_url", help="view server URL Platform to connect to")
+    parser.add_argument("--userid", help="User Id")
+    parser.add_argument("--password", help="User Password")
+    args = parser.parse_args()
+
+    integ_server = (
+        args.integ_server
+        if args.integ_server is not None
+        else EGERIA_INTEGRATION_DAEMON
+    )
+    integ_url = (
+        args.integ_url if args.integ_url is not None else EGERIA_INTEGRATION_DAEMON_URL
+    )
+    view_server = (
+        args.view_server if args.view_server is not None else EGERIA_VIEW_SERVER
+    )
+    view_url = args.view_url if args.view_url is not None else EGERIA_VIEW_SERVER_URL
+    userid = args.userid if args.userid is not None else EGERIA_USER
+    user_pass = args.password if args.password is not None else EGERIA_USER_PASSWORD
+    display_integration_daemon_status(
+        integ_server=integ_server,
+        integ_url=integ_url,
+        view_server=view_server,
+        view_url=view_url,
+        user=userid,
+        user_pass=user_pass,
+        paging=True,
+    )
+
+
+if __name__ == "__main__":
+    main_live()
+
+if __name__ == "__main_paging__":
+    main_paging()

examples/widgets/ops/monitor_platform_status.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Display the status of cataloged platforms and servers.
+"""
+
+import argparse
+import os, sys
+import time
+
+from rich.console import Console
+from rich.live import Live
+from rich.table import Table
+
+from pyegeria import RuntimeManager
+from pyegeria._exceptions import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+
+EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
+EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
+EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
+EGERIA_VIEW_SERVER = os.environ.get("VIEW_SERVER", "view-server")
+EGERIA_VIEW_SERVER_URL = os.environ.get(
+    "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
+)
+EGERIA_INTEGRATION_DAEMON = os.environ.get("INTEGRATION_DAEMON", "integration-daemon")
+EGERIA_INTEGRATION_DAEMON_URL = os.environ.get(
+    "EGERIA_INTEGRATION_DAEMON_URL", "https://localhost:9443"
+)
+EGERIA_ADMIN_USER = os.environ.get("ADMIN_USER", "garygeeke")
+EGERIA_ADMIN_PASSWORD = os.environ.get("ADMIN_PASSWORD", "secret")
+EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+EGERIA_JUPYTER = bool(os.environ.get("EGERIA_JUPYTER", "False"))
+EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
+
+disable_ssl_warnings = True
+console = Console(width=200)
+
+
+def display_status(
+    server: str,
+    url: str,
+    username: str,
+    user_pass: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+):
+    r_client = RuntimeManager(server, url, username)
+    token = r_client.create_egeria_bearer_token(username, user_pass)
+
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"Server Status for Platform - {time.asctime()}",
+            # style="bold white on black",
+            row_styles=["bold white on black"],
+            header_style="white on dark_blue",
+            title_style="bold white on black",
+            caption_style="white on black",
+            caption=f"Status of Platforms - '{url}'",
+            show_lines=True,
+            # expand=True
+        )
+        table.add_column("Platform Name")
+        # table.add_column("Platform GUID")
+        table.add_column("Platform URL")
+        table.add_column("Platform Origin")
+        table.add_column("Description")
+        table.add_column("Platform Started")
+        table.add_column("Servers")
+
+        server_types = {
+            "Metadata Access Store": "Store",
+            "View Server": "View",
+            "Engine Host Server": "EngineHost",
+            "Integration Daemon": "Integration",
+        }
+        try:
+            platform_list = r_client.get_platforms_by_type()
+            if type(platform_list) is str:
+                print("No OMAG Server Platforms found?")
+                sys.exit(1)
+
+            for platform in platform_list:
+                platform_name = platform["properties"].get("displayName", "---")
+                platform_guid = platform["elementHeader"]["guid"]
+                platform_desc = platform["properties"].get("resourceDescription", "---")
+                server_list = ""
+
+                platform_report = r_client.get_platform_report(platform_guid)
+                platform_url = platform_report.get("platformURLRoot", " ")
+                platform_origin = platform_report.get("platformOrigin", " ")
+                platform_started = platform_report.get("platformStartTime", " ")
+
+                servers = platform_report.get("omagservers", None)
+
+                if servers is not None:
+                    for server in servers:
+                        server_name = server.get("serverName", " ")
+                        server_type = server.get("serverType", " ")
+                        server_status = server.get("serverActiveStatus", "UNKNOWN")
+                        if server_status in ("RUNNING", "STARTING"):
+                            status_flag = "[bright green]"
+                        elif server_status in ("INACTIVE", "STOPPING"):
+                            status_flag = "[bright red]"
+                        else:
+                            server_status = "UNKNOWN"
+                            status_flag = "[bright yellow]"
+
+                        server_list = (
+                            f"{status_flag}{server_types[server_type]}: {server_name}\n"
+                        )
+                        # server_list = server_list + serv
+
+                    table.add_row(
+                        platform_name,
+                        platform_url,
+                        platform_origin,
+                        platform_desc,
+                        platform_started,
+                        server_list,
+                        style="bold white on black",
+                    )
+
+        except Exception as e:
+            # console.print_exception(e)
+            platform_url = " "
+            platform_origin = " "
+            platform_started = " "
+
+        return table
+
+    try:
+        with Live(generate_table(), refresh_per_second=4, screen=True) as live:
+            while True:
+                time.sleep(2)
+                live.update(generate_table())
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+
+    except KeyboardInterrupt:
+        pass
+    finally:
+        r_client.close_session()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--server", help="Name of the server to display status for")
+    parser.add_argument("--url", help="URL Platform to connect to")
+    parser.add_argument("--userid", help="User Id")
+    parser.add_argument("--password", help="User Password")
+    args = parser.parse_args()
+
+    server = args.server if args.server is not None else EGERIA_VIEW_SERVER
+    url = args.url if args.url is not None else EGERIA_PLATFORM_URL
+    userid = args.userid if args.userid is not None else EGERIA_USER
+    user_pass = args.password if args.password is not None else EGERIA_USER_PASSWORD
+
+    display_status(server, url, userid, user_pass)
+
+
+if __name__ == "__main__":
+    main()