agilicus 1.303.5__py3-none-any.whl → 1.402.0__py3-none-any.whl

agilicus/apps.py

@@ -2,6 +2,7 @@ import os
 import json
 import urllib.parse
 import agilicus
+import re
 import requests
 
 from . import context, response
@@ -14,6 +15,7 @@ from .input_helpers import (
     update_org_from_input_or_ctx,
     update_if_not_none,
 )
+from .pagination import normalize_page_args
 
 from .output.table import (
     spec_column,
@@ -24,9 +26,14 @@ from .output.table import (
     subtable,
 )
 
+from .resource_helpers import standard_page_fields
+
 
 CONNECTION_MAPPING_OPTS = ("default", "one-to-one")
 
+application_service_page_fields = standard_page_fields
+page_fields = standard_page_fields
+
 
 def _prepare_for_put(application):
     application.pop("id", None)
@@ -66,7 +73,7 @@ def query(
     params.update(kwargs)
 
     params["show_status"] = True
-
+    params = normalize_page_args(params)
     query_results = apiclient.application_api.list_applications(**params)
     return query_results.applications
 
@@ -561,6 +568,14 @@ def update_application_configs(  # noqa
     client_injection_login_form_username_field=None,
     client_injection_login_form_password_field=None,
     client_injection_debug=None,
+    client_injection_login_form_username_credential=None,
+    client_injection_login_form_password_credential=None,
+    client_injection_login_form_username_query_selector=None,
+    client_injection_login_form_password_query_selector=None,
+    client_injection_login_form_username_next_selector=None,
+    client_injection_login_form_password_next_selector=None,
+    client_injection_login_form_login_selector=None,
+    client_injection_login_form_submit_selector=None,
     **kwargs,
 ):
     additional_context = config.setdefault("additional_context", {})
@@ -695,6 +710,64 @@ def update_application_configs(  # noqa
         form_config = login_config.setdefault("form_config", {})
         form_config["password_field"] = client_injection_login_form_password_field
 
+    if client_injection_login_form_username_credential is not None:
+        login_config = _get_login_config()
+        form_config = login_config.setdefault("form_config", {})
+        form_config["username_credential"] = (
+            client_injection_login_form_username_credential
+        )
+
+    if client_injection_login_form_password_credential is not None:
+        login_config = _get_login_config()
+        form_config = login_config.setdefault("form_config", {})
+        form_config["password_credential"] = (
+            client_injection_login_form_password_credential
+        )
+
+    if client_injection_login_form_username_query_selector is not None:
+        login_config = _get_login_config()
+        inject_form_config = login_config.setdefault("form_config", {})
+        form_config = inject_form_config.setdefault("config", {})
+        form_config["username_query_selector"] = (
+            client_injection_login_form_username_query_selector
+        )
+
+    if client_injection_login_form_password_query_selector is not None:
+        login_config = _get_login_config()
+        inject_form_config = login_config.setdefault("form_config", {})
+        form_config = inject_form_config.setdefault("config", {})
+        form_config["password_query_selector"] = (
+            client_injection_login_form_password_query_selector
+        )
+
+    if client_injection_login_form_username_next_selector is not None:
+        login_config = _get_login_config()
+        inject_form_config = login_config.setdefault("form_config", {})
+        form_config = inject_form_config.setdefault("config", {})
+        form_config["username_next_selector"] = (
+            client_injection_login_form_username_next_selector
+        )
+
+    if client_injection_login_form_password_next_selector is not None:
+        login_config = _get_login_config()
+        inject_form_config = login_config.setdefault("form_config", {})
+        form_config = inject_form_config.setdefault("config", {})
+        form_config["password_next_selector"] = (
+            client_injection_login_form_password_next_selector
+        )
+
+    if client_injection_login_form_login_selector is not None:
+        login_config = _get_login_config()
+        inject_form_config = login_config.setdefault("form_config", {})
+        form_config = inject_form_config.setdefault("config", {})
+        form_config["login_selector"] = client_injection_login_form_login_selector
+
+    if client_injection_login_form_submit_selector is not None:
+        login_config = _get_login_config()
+        inject_form_config = login_config.setdefault("form_config", {})
+        form_config = inject_form_config.setdefault("config", {})
+        form_config["submit_selector"] = client_injection_login_form_submit_selector
+
 
 def update_oidc_standard_headers(
     cfg,
@@ -963,6 +1036,7 @@ def get_application_services(ctx, org_id=None, **kwargs):
     apiclient = context.get_apiclient(ctx, token)
     params = {}
     update_if_not_none(params, kwargs)
+    params = normalize_page_args(params)
     return apiclient.app_services_api.list_application_services(
         **params,
     ).application_services
@@ -1087,7 +1161,7 @@ def update_application_service(  # noqa: C901
             service.protocol_config.expose_config = agilicus.ServiceExposeConfig()
         service.protocol_config.expose_config.expose_as_hostname = expose_as_hostname
 
-    service.config = _configure_port(service.config, port_range)
+    service.config = configure_port(service.config, port_range)
     if source_port_override is not None:
         service.config.source_port_override = source_port_override
     if source_address_override is not None:
@@ -1106,26 +1180,41 @@ def update_application_service(  # noqa: C901
     ).to_dict()
 
 
-def _configure_port(config, port_range):
+def configure_port(config, port_range):
     if port_range is None:
         return config
 
     if not config:
         config = agilicus.NetworkServiceConfig()
 
-    config.ports = _parse_ports(port_range)
+    config.ports = parse_ports(port_range)
     return config
 
 
-def _parse_ports(ports):
+def parse_ports(ports):
+    port_regex = re.compile(r"^(?P<proto>[tu])?(?P<range>[\d]+(?:-[\d]+)?)$")
     port_ranges = ports.split(",")
 
     result = []
     for port_range in port_ranges:
-        parts = port_range.split("-")
-        if len(parts) > 2:
-            raise ValueError("each port range must be a or a-b")
-        result.append(agilicus.NetworkPortRange(port=agilicus.NetworkPort(port_range)))
+        match = port_regex.match(port_range)
+        if not match:
+            raise ValueError(
+                "each port range must be a or a-b and optionally start with t (tcp) or u"
+                " (udp)"
+            )
+
+        protocol = "tcp"
+        if match.group("proto") == "u":
+            protocol = "udp"
+        range = match.group("range")
+
+        result.append(
+            agilicus.NetworkPortRange(
+                port=agilicus.NetworkPort(range),
+                protocol=protocol,
+            )
+        )
 
     return result
 

agilicus/audit_destinations.py

@@ -21,7 +21,7 @@ from .output.table import (
     subtable,
 )
 
-DESTINATION_TYPES = ["file", "webhook", "graylog", "connector"]
+DESTINATION_TYPES = ["file", "webhook", "graylog", "connector", "syslog"]
 FILTER_TYPES = ["subsystem", "audit_agent_type", "audit_agent_id", "hostname"]
 AUTH_TYPES = ["none", "http_basic", "http_bearer", "agilicus_bearer"]
 

agilicus/connectors.py

@@ -8,6 +8,7 @@ from . import get_many_entries
 import agilicus_api.exceptions
 import dateutil.tz
 import operator
+import urllib.parse
 from colorama import Fore
 import re
 from typing import Optional
@@ -22,6 +23,8 @@ from agilicus import input_helpers
 from .orgs import get_org_by_dictionary
 from . import create_or_update
 from .custom_types import Ternary
+from . import pagination
+from .resource_helpers import standard_page_fields
 
 from .output.table import (
     spec_column,
@@ -33,6 +36,9 @@ from .output.table import (
 )
 
 TUNNEL_TERMINATION_TYPES = ["tcp", "inproc"]
+INTERNAL_SERVICE_BIND = ["disabled", "local", "all", "custom"]
+
+page_fields = standard_page_fields
 
 
 def _filter_version(connector, not_version=None, only_version=None):
@@ -104,6 +110,7 @@ def query(
     page_at_id=None,
     page_size=500,
     filter_os_version=None,
+    page_on=None,
     **kwargs,
 ):
     token = context.get_token(ctx)
@@ -115,14 +122,20 @@ def query(
     if page_at_id is None:
         page_at_id = ""
     input_helpers.update_if_not_none(params, kwargs)
-    query_results = get_many_entries(
-        apiclient.connectors_api.list_connector,
-        "connectors",
-        maximum=kwargs.get("limit", None),
-        page_size=page_size,
-        page_at_id=page_at_id,
-        **params,
-    )
+    params = pagination.normalize_page_args(params)
+    if page_on is None:
+        query_results = get_many_entries(
+            apiclient.connectors_api.list_connector,
+            "connectors",
+            maximum=kwargs.get("limit", None),
+            page_size=page_size,
+            page_at_id=page_at_id,
+            **params,
+        )
+    else:
+        query_results = apiclient.connectors_api.list_connector(
+            page_on=page_on, **params
+        ).connectors
     return do_filter(
         ctx,
         no_down,
@@ -169,6 +182,7 @@ def query_agents(ctx, column_format=None, filter_not_has_version=None, **kwargs)
 
     if org_id:
         kwargs["org_id"] = org_id
+    kwargs = pagination.normalize_page_args(kwargs)
     query_results = apiclient.connectors_api.list_agent_connector(
         **strip_none(kwargs)
     ).agent_connectors
@@ -665,6 +679,8 @@ def replace_agent(
     trap_disabled=None,
     revocation_proxy_trusted_cert_bundle_id=None,
     revocation_proxy_rules_bundle_id=None,
+    ntp_forwarding_bind=None,
+    ntp_forwarding_custom_bind=None,
     **kwargs,
 ):
     token = context.get_token(ctx)
@@ -708,8 +724,10 @@ def replace_agent(
             cloud_routing.point_of_presence_tags = tags
 
         connector.spec.cloud_routing = cloud_routing
-
-    _update_tunneling(connector, dynamic_routes_enabled, on_demand_routes_enabled)
+    _update_tunneling(
+        connector, dynamic_routes_enabled, on_demand_routes_enabled, ntp_forwarding_bind
+    )
+    _update_ntp_forwarding(connector, ntp_forwarding_bind, ntp_forwarding_custom_bind)
 
     if admin_status is not None:
         connector.spec.admin_status = admin_status
@@ -731,7 +749,33 @@ def replace_agent(
     return _replace_agent(apiclient, connector_id=connector_id, connector=connector)
 
 
-def _update_tunneling(connector, dynamic_routes_enabled, on_demand_routes_enabled):
+def _update_ntp_forwarding(connector, ntp_forwarding_bind, custom_bind):
+    if ntp_forwarding_bind is None:
+        return
+    routing = connector.spec.routing
+    if routing is None:
+        routing = agilicus.AgentConnectorCloudRouting(local_binds=[])
+    connector.spec.routing = routing
+
+    internal_networks = routing.internal_networks
+    if not internal_networks:
+        internal_networks = agilicus.InternalNetworkRouting()
+    ntp = internal_networks.ntp
+    if not ntp:
+        ntp = agilicus.NTPInternalNetworkRouting()
+    ntp.bind = agilicus.InternalNetworkBind(ntp_forwarding_bind)
+    if custom_bind is not None:
+        parts = urllib.parse.urlsplit("//" + custom_bind)
+        ntp.bind.custom_bind = agilicus.AgentConnectorLocalBind(
+            bind_host=parts.hostname, bind_port=parts.port or 123
+        )
+    internal_networks.ntp = ntp
+    routing.internal_networks = internal_networks
+
+
+def _update_tunneling(
+    connector, dynamic_routes_enabled, on_demand_routes_enabled, ntp_forwarding_bind
+):
     if dynamic_routes_enabled is None and on_demand_routes_enabled is None:
         return
 

agilicus/context.py

@@ -93,6 +93,9 @@ class ApiHelper:
         self.licensing_api = agilicus.LicensingApi(
             agilicus.ApiClient(self.configuration)
         )
+        self.deployments_api = agilicus.DeploymentsApi(
+            agilicus.ApiClient(self.configuration)
+        )
 
     def refresh_token(self):
         self.configuration.access_token = get_token(self.ctx)

agilicus/databases/databases.py

@@ -10,20 +10,24 @@ from agilicus import agilicus_api
 from ..input_helpers import build_updated_model
 from ..input_helpers import update_org_from_input_or_ctx
 from ..input_helpers import strip_none
+from ..pagination import normalize_page_args
 from ..output.table import (
     spec_column,
     format_table,
     metadata_column,
 )
-from ..resource_helpers import map_resource_published
+from ..resource_helpers import map_resource_published, standard_page_fields
 
 PROTOCOLS = ["postgresql"]
 
+page_fields = standard_page_fields
+
 
 def list_database_resources(ctx, **kwargs):
     apiclient = context.get_apiclient_from_ctx(ctx)
     update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
     params = strip_none(kwargs)
+    params = normalize_page_args(params)
     query_results = apiclient.app_services_api.list_database_resources(**params)
     return query_results.database_resources
 

agilicus/databases/databases_main.py

@@ -5,6 +5,7 @@ from ..output.table import output_entry
 from agilicus.command_helpers import Command
 
 from . import databases
+from ..input_helpers import page_sort_order_values, search_direction_values
 
 cmd = Command()
 
@@ -18,6 +19,16 @@ cmd = Command()
 @click.option("--updated-since", default=None, type=click.DateTime())
 @click.option("--resource-id", default=None)
 @click.option("--limit", default=500)
+@click.option(
+    "--page-on", multiple=True, type=click.Choice(databases.page_fields), default=None
+)
+@click.option("--page-at-key", multiple=True, type=str, default=None)
+@click.option(
+    "--page-sort", multiple=True, type=click.Choice(page_sort_order_values), default=None
+)
+@click.option(
+    "--search-direction", type=click.Choice(search_direction_values), default=None
+)
 @click.pass_context
 def list_database_resources(ctx, name=None, **kwargs):
     resources = databases.list_database_resources(ctx, name=name, **kwargs)

agilicus/deployments/deployments.py

@@ -0,0 +1,152 @@
+from .. import context
+import yaml
+import agilicus
+from ..input_helpers import update_org_from_input_or_ctx, pop_item_if_none
+from .. import create_or_update
+
+
+def list_deployments(ctx, **kwargs):
+    token = context.get_token(ctx)
+    update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
+    apiclient = context.get_apiclient(ctx, token)
+    return apiclient.deployments_api.list_deployments(**kwargs).deployments
+
+
+def get_deployment(ctx, deployment_id, **kwargs):
+    token = context.get_token(ctx)
+    update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
+    apiclient = context.get_apiclient(ctx, token)
+    return apiclient.deployments_api.get_deployment(deployment_id, **kwargs)
+
+
+def delete_deployment(ctx, deployment_id, **kwargs):
+    token = context.get_token(ctx)
+    update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
+    apiclient = context.get_apiclient(ctx, token)
+    return apiclient.deployments_api.delete_deployment(deployment_id, **kwargs)
+
+
+def add_deployment(ctx, schema=None, **kwargs):
+    config_data = {}
+    if schema:
+        with open(schema, "r") as file:
+            config_data = yaml.safe_load(file)
+    pop_item_if_none(kwargs)
+    token = context.get_token(ctx)
+    update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
+    apiclient = context.get_apiclient(ctx, token)
+
+    deployment = agilicus.Deployment(
+        agilicus.DeploymentSpec(**kwargs, schema=config_data)
+    )
+    return apiclient.deployments_api.create_deployment(deployment)
+
+
+def list_deployment_instances(ctx, **kwargs):
+    token = context.get_token(ctx)
+    update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
+    apiclient = context.get_apiclient(ctx, token)
+    return apiclient.deployments_api.list_deployment_instances(
+        **kwargs
+    ).deployment_instances
+
+
+def get_deployment_instance(ctx, deployment_instance_id, **kwargs):
+    token = context.get_token(ctx)
+    update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
+    apiclient = context.get_apiclient(ctx, token)
+    return apiclient.deployments_api.get_deployment_instance(
+        deployment_instance_id, **kwargs
+    )
+
+
+def add_deployment_instance(ctx, input, **kwargs):
+    pop_item_if_none(kwargs)
+    token = context.get_token(ctx)
+    update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
+    apiclient = context.get_apiclient(ctx, token)
+
+    inputs = []
+    for _input in input:
+        split_str = _input.split(",")
+        name = split_str[0]
+        value = split_str[1]
+        inputs.append(agilicus.DeploymentInstanceInput(name=name, value_as_string=value))
+    instance = agilicus.DeploymentInstance(
+        agilicus.DeploymentInstanceSpec(inputs=inputs, **kwargs)
+    )
+    return apiclient.deployments_api.create_deployment_instance(instance)
+
+
+def delete_deployment_instance(ctx, deployment_instance_id, **kwargs):
+    token = context.get_token(ctx)
+    update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
+    apiclient = context.get_apiclient(ctx, token)
+    return apiclient.deployments_api.delete_deployment_instance(
+        deployment_instance_id, **kwargs
+    )
+
+
+def list_deployment_templates(ctx, **kwargs):
+    pop_item_if_none(kwargs)
+    token = context.get_token(ctx)
+    update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
+    apiclient = context.get_apiclient(ctx, token)
+    return apiclient.deployments_api.list_deployment_templates(
+        **kwargs
+    ).deployment_templates
+
+
+def get_deployment_template(ctx, deployment_template_id, **kwargs):
+    token = context.get_token(ctx)
+    update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
+    apiclient = context.get_apiclient(ctx, token)
+    return apiclient.deployments_api.get_deployment_template(
+        deployment_template_id, **kwargs
+    )
+
+
+def add_deployment_template(ctx, template, **kwargs):
+    with open(template, "r") as file:
+        config_data = yaml.safe_load(file)
+        add_deployment_template_from_dict(ctx, config_data, **kwargs)
+
+
+def add_deployment_template_from_dict(ctx, template, **kwargs):
+    pop_item_if_none(kwargs)
+    token = context.get_token(ctx)
+    update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
+    apiclient = context.get_apiclient(ctx, token)
+
+    deployment_template = agilicus.DeploymentTemplate(
+        agilicus.DeploymentTemplateSpec(**kwargs, template=template)
+    )
+
+    return create_or_update(
+        deployment_template,
+        apiclient.deployments_api.create_deployment_template,
+        apiclient.deployments_api.update_deployment_template,
+    )
+
+
+def update_system_templates(ctx, templates, **kwargs):
+    with open(templates, "r") as file:
+        config_data = yaml.safe_load(file)
+        for template_type, v in config_data.items():
+            for name, template_dict in v.items():
+                add_deployment_template_from_dict(
+                    ctx,
+                    name=name,
+                    template=template_dict,
+                    template_type=template_type,
+                    **kwargs,
+                )
+
+
+def delete_deployment_template(ctx, deployment_template_id, **kwargs):
+    token = context.get_token(ctx)
+    update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
+    apiclient = context.get_apiclient(ctx, token)
+    return apiclient.deployments_api.delete_deployment_template(
+        deployment_template_id, **kwargs
+    )