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

examples/widgets/ops/README.md

@@ -0,0 +1,24 @@
+<!-- SPDX-License-Identifier: CC-BY-4.0 -->
+<!-- Copyright Contributors to the Egeria project. -->
+
+# Operational
+
+These widgets display different kinds of information useful to monitor the status of different elements of an Egeria deployment.
+Widgets will continue to be added over time to cover more facets of catalog use.
+
+* get_eng_action_status.py - lists assets containing the user provided search string in the display name or qualified name. Search string must be a minimum of three characters.
+* get_tech_type_elements.py - shows a tree view for the details of a supported technology type.
+* get_tech_type_template.py - shows a tree view of the template associated with a supported technology type.
+* view_coco_status.py - provides a tree view of a collection with all nested collections and items within the collection.
+* view_eng_action_status.py - provides a live view of the status of engine actions.
+* view_gov_eng_status.py - provides a live view of a governance engine status.
+* view_integ_daemeon_status.py - provides a live view of an integration daemon status.
+* view_platform_status.py - provides a live status view of the known servers on known platforms.
+* view_server_list.py - provides a more detailed live status view of the servers on a single platform.
+* view_server_status.py - provides a minimal live status view of the servers on a single platform.
+* view_asset_changes.py - experiment in progress
+* view_asset_events.py - experiment in progress
+
+----
+License: [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/),
+Copyright Contributors to the Egeria project.

examples/widgets/ops/__init__.py

@@ -0,0 +1,19 @@
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+"""
+import pyegeria
+# from .ops_config import Config
+
+# import monitor_gov_eng_status
+# import monitor_server_status
+# import monitor_server_list
+# import monitor_integ_daemon_status
+# import monitor_platform_status
+# import monitor_engine_activity
+# import refresh_integration_daemon
+# import restart_integration_daemon
+# import integration_daemon_actions
+# import list_catalog_targets

examples/widgets/ops/engine_actions.py

@@ -0,0 +1,83 @@
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+
+Execute engine actions.
+
+"""
+import os
+
+import click
+
+# from ops_config import Config, pass_config
+from pyegeria import Platform
+from pyegeria._exceptions import (
+    InvalidParameterException,
+    PropertyServerException,
+    print_exception_response,
+)
+
+GERIA_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")
+
+
+@click.command("stop")
+@click.option(
+    "--server", default=EGERIA_VIEW_SERVER, help="Egeria metadata store to load"
+)
+@click.option(
+    "--url", default=EGERIA_VIEW_SERVER_URL, help="URL of Egeria platform to connect to"
+)
+@click.option("--userid", default=EGERIA_ADMIN_USER, help="Egeria admin user")
+@click.option("--password", default=EGERIA_ADMIN_PASSWORD, help="Egeria admin password")
+@click.option("--timeout", default=60, help="Number of seconds to wait")
+def stop_daemon(file, server, url, userid, password, timeout):
+    """Stop an engine-host daemon"""
+    p_client = Platform(server, url, userid, password)
+    try:
+        p_client.shutdown_server()
+
+        click.echo(f"Stopped server {server}")
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+    finally:
+        p_client.close_session()
+
+
+@click.command("start")
+@click.option(
+    "--server", default=EGERIA_VIEW_SERVER, help="Egeria metadata store to load"
+)
+@click.option(
+    "--url", default=EGERIA_VIEW_SERVER_URL, help="URL of Egeria platform to connect to"
+)
+@click.option("--userid", default=EGERIA_ADMIN_USER, help="Egeria admin user")
+@click.option("--password", default=EGERIA_ADMIN_PASSWORD, help="Egeria admin password")
+@click.option("--timeout", default=60, help="Number of seconds to wait")
+def start_daemon(file, server, url, userid, password, timeout):
+    """Start or restart an engine-host from its known configuration"""
+    p_client = Platform(server, url, userid, password)
+    try:
+        p_client.activate_server_stored_config()
+
+        click.echo(f"Started server {server}")
+
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+    finally:
+        p_client.close_session()

examples/widgets/ops/integration_daemon_actions.py

@@ -0,0 +1,139 @@
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+
+This script restarts an integration daemon.
+
+"""
+
+import os
+from rich import print, print_json
+from rich.console import Console
+
+import click
+from pyegeria import ServerOps, AutomatedCuration, INTEGRATION_GUIDS, Platform
+from pyegeria._exceptions import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+)
+
+
+@click.command("add-target")
+@click.argument("integration-connector")
+@click.argument("metadata-element-guid")
+@click.argument("catalog-target-name")
+@click.pass_context
+def add_catalog_target(
+    ctx,
+    integration_connector: str,
+    metadata_element_guid: str,
+    catalog_target_name: str,
+) -> str:
+    """Add catalog targets to the specified integration connector"""
+    try:
+        if integration_connector not in INTEGRATION_GUIDS.keys():
+            click.echo("Integration connector is not known")
+
+        c = ctx.obj
+        a_client = AutomatedCuration(
+            c.view_server, c.view_server_url, c.userid, c.password
+        )
+        token = a_client.create_egeria_bearer_token()
+
+        guid = a_client.add_catalog_target(
+            INTEGRATION_GUIDS[integration_connector],
+            metadata_element_guid,
+            catalog_target_name,
+        )
+
+        click.echo(
+            f"Added catalog target to {integration_connector} with a return guid of {guid}"
+        )
+
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+
+
+@click.command("remove-target")
+@click.argument("relationship-guid")
+@click.pass_context
+def remove_catalog_target(ctx, relationship_guid: str):
+    """Remove the catalog target specified by the relationship guidr"""
+    try:
+        c = ctx.obj
+        a_client = AutomatedCuration(
+            c.view_server, c.view_server_url, c.userid, c.password
+        )
+        token = a_client.create_egeria_bearer_token()
+
+        a_client.remove_catalog_target(relationship_guid)
+
+        click.echo(
+            f"Removed catalog target with relationship guid of {relationship_guid}"
+        )
+
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+
+
+@click.command("update-target")
+@click.argument("relationship-guid")
+@click.argument("catalog-target-name")
+@click.pass_context
+def update_catalog_target(ctx, relationship_guid: str, catalog_target_name: str):
+    """Update the catalog target specified by the relationship guid"""
+    try:
+        c = ctx.obj
+        a_client = AutomatedCuration(
+            c.view_server, c.view_server_url, c.userid, c.password
+        )
+        token = a_client.create_egeria_bearer_token()
+
+        guid = a_client.update_catalog_target(relationship_guid, catalog_target_name)
+
+        click.echo(
+            f"Update catalog target with relationship guid of  {relationship_guid} to a catalog target name of "
+            f"{catalog_target_name} with a return guid of {guid}"
+        )
+
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+
+
+@click.command("stop")
+@click.pass_context
+def stop_server(ctx):
+    """Stop an integration daemon"""
+    try:
+        c = ctx.obj
+        p_client = Platform(
+            c.integration_daemon, c.integration_daemon_url, c.userid, c.password
+        )
+
+        p_client.shutdown_server()
+
+        click.echo(f"Stopped server {c.integration_daemon}")
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+
+
+@click.command("start")
+@click.pass_context
+def start_server(ctx):
+    """Start or restart an integration daemon from its known configuration"""
+    try:
+        c = ctx.obj
+        p_client = Platform(
+            c.integration_daemon, c.integration_daemon_url, c.userid, c.password
+        )
+
+        p_client.activate_server_stored_config()
+
+        click.echo(f"Started server {c.integration_daemon}")
+
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)

examples/widgets/ops/list_catalog_targets.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+
+List catalog targets
+
+"""
+import argparse
+import os
+import time
+
+from rich import box
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.prompt import Prompt
+from rich.table import Table
+
+from pyegeria import (
+    InvalidParameterException,
+    PropertyServerException,
+    UserNotAuthorizedException,
+    print_exception_response,
+    AutomatedCuration,
+    INTEGRATION_GUIDS
+)
+
+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_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'))
+
+
+
+def display_catalog_targets(connector: str, server: str, url: str, username: str, user_password: str,
+                            jupyter: bool = EGERIA_JUPYTER, width: int = EGERIA_WIDTH):
+    console = Console(force_terminal=not jupyter, width=width, soft_wrap=True)
+    def generate_table() -> Table:
+        """Make a new table."""
+        table = Table(
+            title=f"All Catalog Targets for Integration Connector {connector} @ {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",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"Catalog Targets for '{server}' @ Platform - {url}",
+            expand=True
+        )
+        table.add_column("Name of Target")
+        table.add_column("Catalog Target")
+
+        # table.add_column("Relationship GUID", no_wrap=True)
+        table.add_column('Configuration Properties')
+        table.add_column('Template Properties')
+        table.add_column("Operational Instructions", max_width=20)
+        # table.add_column("Delete Method")
+
+        if type(cat_targets) is list:
+            for target in cat_targets:
+                target_name = target.get('catalogTargetName', '---')
+                target_source = target.get('metadataSourceQualifiedName', '---')
+                target_rel = target.get('relationshipGUID', '---')
+                target_sync = target.get('permittedSynchronization')
+                target_delete = target.get('deleteMethod', '---')
+                op_instruct = f"* {target_sync}\n* {target_delete}"
+                op_instruct_out = Markdown(op_instruct)
+                # target_guid = target['catalogTargetElement']['guid']
+                connector_unique = target['catalogTargetElement']['uniqueName']
+
+                cat_target_out = Markdown(f"* Target Name: {target_name}\n* Target Source: {target_source}\n"
+                                          f"* Relationship Guid: {target_rel}")
+
+                config_props = target.get('configurationProperties', '---')
+                if type(config_props) is dict:
+                    config_props_md = ''
+                    for prop in config_props:
+                        config_props_md += f"* {prop}: {config_props[prop]}\n"
+                    config_props_out = Markdown(config_props_md)
+                else:
+                    config_props_out = '---'
+
+                template_props = target.get('templateProperties', '---')
+                if type(template_props) is dict:
+                    template_props_md = ''
+                    for prop in template_props:
+                        template_props_md += f"* {prop}: {template_props[prop]}\n"
+                    template_props_out = Markdown(template_props_md)
+                else:
+                    template_props_out = '---'
+
+                table.add_row(
+                    connector_unique, cat_target_out,
+                    config_props_out, template_props_out, op_instruct_out)
+
+        return table
+
+    try:
+        a_client = AutomatedCuration(server, url, username)
+        token = a_client.create_egeria_bearer_token(username, user_password)
+        if connector not in INTEGRATION_GUIDS.keys():
+            raise Exception
+
+        connector_guid = INTEGRATION_GUIDS[connector]
+        cat_targets = a_client.get_catalog_targets(connector_guid)
+        console = Console(force_terminal=not jupyter, width=width, soft_wrap=True)
+        with console.pager(styles=True):
+            console.print(generate_table(), soft_wrap=True)
+
+    except (InvalidParameterException, PropertyServerException, UserNotAuthorizedException) as e:
+        print_exception_response(e)
+    except Exception as e:
+        print(f"\n\n===> Perhaps integration connector {connector} is not known?\n\n")
+        console.print_exception()
+    finally:
+        a_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")
+    parser.add_argument("--jupyter", help="Enable for Jupyter terminal compatibility")
+    parser.add_argument("--width", help="Screen width, in characters, to use")
+
+    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_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
+    jupyter = args.jupyter if args.jupyter is not None else EGERIA_JUPYTER
+    width = args.width if args.width is not None else EGERIA_WIDTH
+
+    try:
+        connector = Prompt.ask("Enter the Integration Connector to list catalog targets for")
+        display_catalog_targets(connector, server, url, userid, user_pass, jupyter, width=width)
+
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

examples/widgets/ops/load_archive.py

@@ -0,0 +1,62 @@
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+
+
+This script refreshed an integration daemon.
+
+"""
+
+import os
+import argparse
+import time
+import click
+from trogon import tui
+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')
+
+
+@click.command('load-archive')
+@click.option('--file', prompt= "Path on the Metadata Server of the archive file to load",
+              default='content-packs/CocoComboArchive.omarchive',
+              help='Full path on the Metadata Server to the archive file to load')
+@click.option('--server', default = EGERIA_METADATA_STORE, help='Egeria metadata store to load')
+@click.option('--url', default = EGERIA_PLATFORM_URL, help='URL of Egeria platform to connect to')
+@click.option('--userid', default = EGERIA_ADMIN_USER, help='Egeria admin user')
+@click.option('--password', default = EGERIA_ADMIN_PASSWORD, help='Egeria admin password')
+@click.option('--timeout', default = 60, help = 'Number of seconds to wait')
+def load_archive(file, server, url, userid, password, timeout):
+    """Load an Open Metadata Archive"""
+
+    try:
+
+        s_client = ServerOps(server, url, userid, password)
+
+        s_client.add_archive_file(file, server, timeout = timeout)
+
+        click.echo(f"Loaded archive: {file}")
+
+
+    except (InvalidParameterException, PropertyServerException) as e:
+        print_exception_response(e)
+
+
+if __name__ == "__main__":
+    load_archive()

examples/widgets/ops/monitor_asset_events.py

@@ -0,0 +1,102 @@
+#!/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 json
+import os
+import time
+import argparse
+from datetime import datetime
+from rich.prompt import Prompt
+from rich.table import Table
+from rich.live import Live
+from rich.console import Console
+from rich.markdown import Markdown
+from confluent_kafka import Consumer, KafkaException
+
+EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
+EGERIA_KAFKA_ENDPOINT = os.environ.get('KAFKA_ENDPOINT', 'localhost:9192')
+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_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 = os.environ.get('EGERIA_JUPYTER', False)
+EGERIA_WIDTH = os.environ.get('EGERIA_WIDTH', 200)
+
+def main(ep: str = EGERIA_KAFKA_ENDPOINT):
+
+    disable_ssl_warnings = True
+    console = Console(width=200)
+    now = datetime.now()
+    current_time = now.strftime("%H:%M:%S")
+
+    earliest_latest = Prompt.ask("Msgs from earliest or latest:", default="earliest")
+
+    # Define the Kafka consumer configuration.
+    config = {
+        'bootstrap.servers': ep,  # replace with your Kafka broker(s)
+        'group.id': f"view_asset_events:{current_time}",  # replace with your consumer group
+        'auto.offset.reset': earliest_latest  # can be set to 'earliest' or 'latest'
+    }
+    print(f"Kafka config is {json.dumps(config)}")
+    # Initialize a Kafka consumer.
+    consumer = Consumer(config)
+
+    # Subscribe to a Kafka topic.
+    consumer.subscribe(['egeria.omag.server.active-metadata-store.omas.assetconsumer.outTopic'])  # replace with your Kafka topic
+
+    try:
+        while True:
+            msg = consumer.poll(2.0)  # timeout set to 1 second
+
+            if msg is None:
+                continue
+            elif msg.error():
+                raise KafkaException(msg.error())
+            else:
+                event = json.loads(msg.value())
+                event_time = event["eventTime"]
+                event_type = event["eventType"]
+                guid = event["elementHeader"]["guid"]
+
+                type_name = event["elementHeader"]["type"]["typeName"]
+                origin = event["elementHeader"]["origin"]["sourceServer"]
+
+                element_properties = event["elementProperties"]
+                element_properties_keys = element_properties.keys()
+                props = " "
+                for key in element_properties_keys:
+                    value = element_properties[key]
+                    props += f"* {key}: {value}\n"
+                console.rule(style= "[bold red]")
+                console.rule(f"\tMessage TimeStamp: {event_time}\t eventType: {event_type}\t typeName: {type_name}\t guid: {guid}")
+                msg = (
+
+                          f"properties: \n[bright white on black]{props}\n\n")
+                msg = Markdown(msg)
+
+                console.print(msg)
+
+    except KeyboardInterrupt:
+        pass
+
+    finally:
+        # Close down consumer to commit final offsets.
+        consumer.close()
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--ep", help="Endpoint to connect to")
+    args = parser.parse_args()
+
+    ep = args.ep if args.ep is not None else EGERIA_KAFKA_ENDPOINT
+
+    main(ep)