agilicus 1.289.5__py3-none-any.whl → 1.401.1__py3-none-any.whl

agilicus/file_shares.py

@@ -13,13 +13,17 @@ from .output.table import (
     format_table,
     metadata_column,
 )
-from .resource_helpers import map_resource_published
+from .pagination import normalize_page_args
+from .resource_helpers import map_resource_published, standard_page_fields
+
+page_fields = standard_page_fields
 
 
 def list_file_share_services(ctx, **kwargs):
     apiclient = context.get_apiclient_from_ctx(ctx)
     update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
     kwargs = strip_none(kwargs)
+    kwargs = normalize_page_args(kwargs)
     query_results = apiclient.app_services_api.list_file_share_services(**kwargs)
     return query_results.file_share_services
 

agilicus/files.py

@@ -73,7 +73,7 @@ def upload(
 
     multipart_form_data = {}
     multipart_form_data["md5_hash"] = md5_hash
-    multipart_form_data["file_zip"] = (name, open(filename, "r"))
+    multipart_form_data["file_zip"] = (name, open(filename, "rb"))
 
     if org_id:
         multipart_form_data["org_id"] = (None, org_id)

agilicus/files_pkg/file_templates.py

@@ -17,7 +17,7 @@ from ..output.table import (
 )
 
 from ..files import upload
-from ..users import get_user
+from ..users import get_user, list_user_resource_access_info
 
 
 def _args_from_list(arg_list):
@@ -102,7 +102,7 @@ def replace_file_template(
             for param in parameters or []
         ]
     if default_arguments:
-        spec.default_arguments = (_args_from_list(default_arguments),)
+        spec.default_arguments = _args_from_list(default_arguments)
     if rendered_file_name:
         spec.rendered_file_name = rendered_file_name
     if associated_objects:
@@ -158,6 +158,7 @@ def render_file_template(
     as_attachment=False,
     org_id=None,
     user_id=None,
+    no_access_info=False,
 ) -> io.BufferedReader:
     token = context.get_token(ctx)
     apiclient = context.get_apiclient(ctx, token)
@@ -173,15 +174,32 @@ def render_file_template(
         request._check_type = False
         request.user_information = user
         request._check_type = True
-    if resource_id is not None:
-        svc = apiclient.app_services_api.get_application_service(
-            resource_id, org_id=org_id
-        )
-        request.resource_information = resource_info_from_app_svc(svc)
+
+    _add_resource_info(
+        ctx, apiclient, request, resource_id, user_id, no_access_info, org_id
+    )
 
     return apiclient.files_api.render_file_template(file_template_id, request)
 
 
+def _add_resource_info(
+    ctx, apiclient, request, resource_id, user_id, no_access_info, org_id
+):
+    if not resource_id:
+        return
+    if not no_access_info and user_id:
+        access_info = list_user_resource_access_info(
+            ctx, user_id=user_id, resource_id=resource_id, org_id=org_id
+        )
+        if access_info:
+            request.resource_information = agilicus.FileTemplateResourceInfo()
+            request.resource_information.user_resource_info = access_info[0].status
+            return
+
+    svc = apiclient.app_services_api.get_application_service(resource_id, org_id=org_id)
+    request.resource_information = resource_info_from_app_svc(svc)
+
+
 def resource_info_from_app_svc(svc):
     result = agilicus.FileTemplateResourceInfo(
         org_id=svc.org_id,

agilicus/files_pkg/files_main.py

@@ -154,11 +154,16 @@ def cli_command_delete_file_template(ctx, **kwargs):
 @click.option("--include-user", is_flag=True)
 @click.option("--user-id")
 @click.option("--resource-id")
+@click.option("--no-access-info", is_flag=True, default=False)
 @click.option(
     "--template-argument", multiple=True, type=click.Tuple([str, str]), default=None
 )
 @click.option(
-    "--outfile", type=click.File("wb"), default=None, help="defaults to stdout"
+    # "--outfile", type=click.File("wb"), default=None, help="defaults to stdout"
+    "--outfile",
+    type=str,
+    default=None,
+    help="defaults to stdout",
 )
 @click.option("--org-id")
 @click.option("--compressed", is_flag=True)
@@ -169,8 +174,10 @@ def cli_command_render_file_template(
     result = file_templates.render_file_template(
         ctx, template_arguments=template_argument, **kwargs
     )
-    if outfile is None:
+    if outfile is None or outfile == "-":
         outfile = sys.stdout.buffer
+    else:
+        outfile = open(outfile, "wb")
     if compressed:
         outfile = zipfile.ZipFile(outfile, "w", zipfile.ZIP_DEFLATED)
         outfile.writestr(os.path.basename(result.name), result.read())

agilicus/input_helpers.py

@@ -9,6 +9,9 @@ from typing import Any, Dict
 
 from . import context
 
+search_direction_values = ["forwards", "backwards"]
+page_sort_order_values = ["asc", "desc"]
+
 
 def update_if_not_none(obj: dict, new_values: dict):
     for k, v in new_values.items():

agilicus/issuers.py

@@ -1,5 +1,7 @@
 import agilicus
 import operator
+import sys
+import json
 
 from typing import List
 
@@ -106,8 +108,28 @@ def add(ctx, issuer, org_id, parent_issuer=None, upstream_redirect_uri=None, **k
         issuer_model.parent_issuer = parent_issuer
     if upstream_redirect_uri is not None:
         issuer_model.upstream_redirect_uri = upstream_redirect_uri
-
-    return apiclient.issuers_api.create_issuer(issuer_model).to_dict()
+    try:
+        return apiclient.issuers_api.create_issuer(issuer_model).to_dict()
+    except agilicus.ApiException as e:
+        if e.status == 409:
+            print(f"error creating issuer reason: {e.reason}", file=sys.stderr)
+            iss = _get_issuer_helper(apiclient, org_id, issuer)
+            if not iss:
+                # If there's a conflict
+                return json.loads(e.body)
+            return iss
+        else:
+            raise
+
+
+def _get_issuer_helper(apiclient, org_id, issuer):
+    params = {}
+    params["org_id"] = org_id
+    issuers = apiclient.issuers_api.list_issuers(**params)["issuer_extensions"]
+    for iss in issuers:
+        if iss.issuer == issuer:
+            return {"id": iss.id}
+    return {}
 
 
 def _update_issuer(ctx, issuer_id, updater, **kwargs):
@@ -183,6 +205,7 @@ def update_oidc_upstreams(
     auto_create_status,
     prompt_mode,
     oidc_flavor,
+    client_authorization_type=None,
     **kwargs,
 ):
     token = context.get_token(ctx)
@@ -222,6 +245,8 @@ def update_oidc_upstreams(
                 upstream.prompt_mode = prompt_mode
             if oidc_flavor is not None:
                 upstream.oidc_flavor = oidc_flavor
+            if client_authorization_type is not None:
+                upstream.client_authorization_type = client_authorization_type
             return apiclient.issuers_api.replace_issuer(
                 issuer_id, issuer, **kwargs
             ).to_dict()

agilicus/launchers.py

@@ -9,8 +9,13 @@ from .output.table import (
     column,
     subtable,
 )
+from .pagination import normalize_page_args
+from .resource_helpers import standard_page_fields
+
 import agilicus
 
+page_fields = standard_page_fields
+
 
 def get(ctx, id, **kwargs):
     token = context.get_token(ctx)
@@ -68,6 +73,7 @@ def query(ctx, **kwargs):
     kwargs = input_helpers.strip_none(kwargs)
 
     kwargs["org_id"] = org_id
+    kwargs = normalize_page_args(kwargs)
     query_results = apiclient.launchers_api.list_launchers(**kwargs)
     return query_results.launchers
 

agilicus/licensing/formatters.py

@@ -0,0 +1,26 @@
+from operator import attrgetter
+
+from ..output.table import (
+    column,
+    list_map,
+    expand_dict,
+    summarize,
+)
+
+
+def constraint_columns(num_subtable_rows=10, column_func=column):
+    return [
+        summarize(
+            list_map(
+                column_func("license_constraints", "constraints"), attrgetter("name")
+            ),
+            num_subtable_rows,
+        ),
+        summarize(
+            list_map(
+                expand_dict(column_func("constraint_variables", "variables")),
+                lambda item: item[0],
+            ),
+            num_subtable_rows,
+        ),
+    ]

agilicus/licensing/licenses.py

@@ -0,0 +1,249 @@
+from .. import context
+
+from agilicus import agilicus_api
+
+from ..input_helpers import (
+    build_updated_model,
+    model_from_dict,
+    update_org_from_input_or_ctx,
+)
+from ..input_helpers import strip_none
+from ..output.table import (
+    column,
+    spec_column,
+    format_table,
+    metadata_column,
+    object_subtable,
+)
+
+from .formatters import constraint_columns
+from ..licensing.product_table_versions import list_product_table_versions
+
+
+def list_licenses(ctx, **kwargs):
+    apiclient = context.get_apiclient_from_ctx(ctx)
+    params = strip_none(kwargs)
+    query_results = apiclient.licensing_api.list_licenses(**params)
+    return query_results.licenses
+
+
+def add_license(
+    ctx, product_table_version, product_name, constraints=None, vars=None, **kwargs
+):
+    apiclient = context.get_apiclient_from_ctx(ctx)
+    spec = agilicus_api.LicenseSpec(
+        product_table_version=agilicus_api.ProductTableVersionString(
+            product_table_version
+        ),
+        product_name=agilicus_api.LicensedProductName(product_name),
+        **strip_none(kwargs),
+    )
+    if constraints:
+        spec.license_constraints = build_constraints(constraints)
+    if vars:
+        spec.constraint_variables = build_vars(vars)
+
+    model = agilicus_api.License(spec=spec)
+
+    return apiclient.licensing_api.create_license(model)
+
+
+def _add_constraint_defaults(**kwargs):
+    if "priority" not in kwargs:
+        kwargs["priority"] = 0
+    return kwargs
+
+
+def build_constraints(constraints):
+    return [
+        model_from_dict(
+            agilicus_api.LicenseConstraint, _add_constraint_defaults(**constraint)
+        )
+        for constraint in constraints
+    ]
+
+
+def build_vars(vars):
+    return agilicus_api.LicenseConstraintVariables._from_openapi_data(**vars)
+
+
+def _get_license(ctx, apiclient, license_id, **kwargs):
+    return apiclient.licensing_api.get_license(license_id, **kwargs)
+
+
+def show_license(ctx, license_id, **kwargs):
+    apiclient = context.get_apiclient_from_ctx(ctx)
+    return _get_license(ctx, apiclient, license_id, **kwargs)
+
+
+def delete_license(ctx, license_id, **kwargs):
+    apiclient = context.get_apiclient_from_ctx(ctx)
+    return apiclient.licensing_api.delete_license(license_id, **kwargs)
+
+
+def update_license(
+    ctx,
+    license_id,
+    constraints=None,
+    vars=None,
+    replace_constraints=None,
+    replace_vars=None,
+    subscription_reconcile=None,
+    **kwargs,
+):
+    apiclient = context.get_apiclient_from_ctx(ctx)
+    mapping = _get_license(ctx, apiclient, license_id)
+
+    apply_constraint_and_vars(
+        mapping.spec, constraints, vars, replace_constraints, replace_vars
+    )
+
+    # check_type=False works around nested types not deserializing correctly
+    mapping.spec = build_updated_model(
+        agilicus_api.LicenseSpec, mapping.spec, kwargs, check_type=False
+    )
+
+    query = {}
+    if subscription_reconcile:
+        query["subscription_reconcile"] = subscription_reconcile
+    return apiclient.licensing_api.replace_license(license_id, license=mapping, **query)
+
+
+def apply_constraint_and_vars(obj, constraints, vars, replace_constraints, replace_vars):
+    if not constraints:
+        constraints = {}
+    if not vars:
+        vars = {}
+
+    if not replace_constraints:
+        constraints = build_constraints(constraints) + (obj.license_constraints or [])
+    else:
+        constraints = build_constraints(constraints)
+
+    if not replace_vars and obj.constraint_variables:
+        vars = obj.constraint_variables.to_dict() | vars
+    vars = build_vars(vars)
+
+    obj.license_constraints = constraints
+    obj.constraint_variables = vars
+
+
+def format_licenses(ctx, resources):
+    columns = [
+        metadata_column("id"),
+        spec_column("product_table_version"),
+        spec_column("product_name"),
+        *constraint_columns(10, column_func=spec_column),
+    ]
+
+    return format_table(ctx, resources, columns)
+
+
+def list_license_details(ctx, **kwargs):
+    apiclient = context.get_apiclient_from_ctx(ctx)
+    update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
+    kwargs = strip_none(kwargs)
+
+    result = apiclient.licensing_api.list_license_details(**kwargs)
+    return result.license_details
+
+
+def format_license_details(ctx, resources):
+    columns = [
+        column("org_id"),
+        column("license.metadata.id", "license"),
+        column("license.spec.product_name", "product_name"),
+        column("license.spec.product_table_version", "product_table_version"),
+        *constraint_columns(10),
+    ]
+
+    return format_table(ctx, resources, columns)
+
+
+def list_license_evaluation_contexts(ctx, **kwargs):
+    apiclient = context.get_apiclient_from_ctx(ctx)
+    update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
+    kwargs = strip_none(kwargs)
+
+    result = apiclient.licensing_api.list_license_evaluation_contexts(**kwargs)
+    return result.license_evaluation_contexts
+
+
+def format_license_evaluation_contexts(ctx, resources):
+    usage_columns = [
+        column("num_resources"),
+        column("num_desktops"),
+        column("num_applications"),
+        column("num_networks"),
+        column("num_ssh"),
+        column("num_databases"),
+        column("num_resource_groups"),
+        column("num_fileshares"),
+        column("num_launchers"),
+        column("num_users"),
+        column("num_groups"),
+        column("num_orgs"),
+        column("num_connectors"),
+    ]
+    columns = [
+        column("org_id"),
+        column("subscription_id"),
+        object_subtable(
+            ctx, "license_evaluation_input.subscription.usage", usage_columns, "usage"
+        ),
+    ]
+
+    return format_table(ctx, resources, columns)
+
+
+def get_licensed_product(product_label, product_table):
+    if not product_label:
+        return None
+
+    product_tokens = product_label.split("-")
+
+    if len(product_tokens) == 1:
+        normalized_product_name = "Standard"
+    elif len(product_tokens) >= 2:
+        # everything but the last, which is the currency
+        normalized_product_name = "-".join(product_tokens[:-1])
+
+    for licensed_product in product_table["products"]:
+        if (
+            str(licensed_product["name"]).casefold()
+            == normalized_product_name.casefold()
+        ):
+            return licensed_product["name"]
+    return None
+
+
+def add_license_to_billing_sub(ctx, bsub, product_name=None, product_table_version=None):
+    if bsub.spec.license_id:
+        raise Exception("subscription already has a license_id set!")
+
+    product_table = list_product_table_versions(ctx, published=True, limit=1)
+    product_version = product_table[0]
+
+    if not product_table_version:
+        product_table_version = product_version["spec"]["version"]
+
+    product_table = product_version["spec"].get("product_table")
+    if not product_name:
+        if not bsub.status.product:
+            raise Exception(f"no product for subscription {bsub.metadata.id}")
+
+        product_name = get_licensed_product(
+            bsub.status.product.spec.label, product_table
+        )
+        if not product_name:
+            raise Exception(
+                "could not find a suitable licensed for product label: "
+                f"{bsub.status.product.spec.label}"
+            )
+
+    result = add_license(
+        ctx,
+        product_table_version=str(product_table_version),
+        product_name=str(product_name),
+    )
+    bsub.spec.license_id = result.metadata.id

agilicus/licensing/licensing_main.py

@@ -0,0 +1,193 @@
+import click
+import click_extension
+
+from ..output.table import output_entry
+
+from agilicus.command_helpers import Command
+
+from . import product_table_versions
+from . import licenses
+
+cmd = Command()
+
+
+@cmd.command(name="list-product-table-versions")
+@click.option("--version", default=None)
+@click.option("--published", default=None, type=bool)
+@click.option("--page-at-version", default=None)
+@click.option("--limit", default=500)
+@click.pass_context
+def list_product_table_versions(ctx, **kwargs):
+    resources = product_table_versions.list_product_table_versions(ctx, **kwargs)
+    table = product_table_versions.format_product_table_versions(ctx, resources)
+    print(table)
+
+
+@cmd.command(name="apply-product-table-version")
+@click.option(
+    "--input-file",
+    required=True,
+    type=click_extension.JSONFile("r"),
+    help="the filename; - for stdin",
+)
+@click.pass_context
+def add_product_table_version(ctx, **kwargs):
+    """
+    adds or updates a product table version as specified in a json file. If the
+    table exists, it matches based on the version.
+    """
+    result = product_table_versions.apply_product_table_version(ctx, **kwargs)
+    output_entry(ctx, result.to_dict())
+
+
+@cmd.command(name="show-product-table-version")
+@click.option("--product-table-version-id")
+@click.option("--version")
+@click.pass_context
+def show_product_table_version(ctx, **kwargs):
+    """
+    Shows a product table version, either by ID or version.
+    """
+    result = product_table_versions.show_product_table_version(ctx, **kwargs)
+    output_entry(ctx, result.to_dict())
+
+
+@cmd.command(name="delete-product-table-version")
+@click.argument("product-table-version-id")
+@click.pass_context
+def delete_product_table_version(ctx, product_table_version_id, **kwargs):
+    product_table_versions.delete_product_table_version(
+        ctx, product_table_version_id, **kwargs
+    )
+
+
+@cmd.command(name="list-licenses")
+@click.option("--version", default=None)
+@click.option("--published", default=None, type=bool)
+@click.option("--page-at-version", default=None)
+@click.option("--limit", default=500)
+@click.pass_context
+def list_licenses(ctx, **kwargs):
+    resources = licenses.list_licenses(ctx, **kwargs)
+    table = licenses.format_licenses(ctx, resources)
+    print(table)
+
+
+@cmd.command(name="add-license")
+@click.option("--product-table-version", type=str, required=True)
+@click.option("--product-name", type=str, required=True)
+@click.option(
+    "--constraints",
+    type=click_extension.JSONFile("r"),
+    help="a constraints file; - for stdin",
+)
+@click.option(
+    "--vars",
+    type=click_extension.JSONFile("r"),
+    help="a constraint variables file; - for stdin",
+)
+@click.pass_context
+def add_license(ctx, **kwargs):
+    """
+    adds a license. Override constraints may be specified in a JSON file.
+    """
+    result = licenses.add_license(ctx, **kwargs)
+    output_entry(ctx, result.to_dict())
+
+
+@cmd.command(name="replace-license")
+@click.option("--license-id", required=True)
+@click.option(
+    "--product-table-version",
+    type=str,
+)
+@click.option(
+    "--product-name",
+    type=str,
+)
+@click.option(
+    "--constraints",
+    type=click_extension.JSONFile("r"),
+    help="a constraints file; - for stdin",
+)
+@click.option(
+    "--vars",
+    type=click_extension.JSONFile("r"),
+    help="a constraint variables file; - for stdin",
+)
+@click.option(
+    "--replace-constraints",
+    type=bool,
+    is_flag=True,
+)
+@click.option(
+    "--replace-vars",
+    type=bool,
+    is_flag=True,
+)
+@click.option(
+    "--subscription-reconcile",
+    type=bool,
+    is_flag=True,
+)
+@click.pass_context
+def replace_license(ctx, **kwargs):
+    """
+    replaces a license. Override constraints may be specified in a JSON file.
+    By default constraints and variables are added to/merged. Specify
+    --replace-constraints or --replace-vars to replace them entirely.
+    """
+    result = licenses.update_license(ctx, **kwargs)
+    output_entry(ctx, result.to_dict())
+
+
+@cmd.command(name="show-license")
+@click.option("--license-id", required=True)
+@click.pass_context
+def show_license(ctx, **kwargs):
+    """
+    Shows a license by id
+    """
+    result = licenses.show_license(ctx, **kwargs)
+    output_entry(ctx, result.to_dict())
+
+
+@cmd.command(name="delete-license")
+@click.argument("license-id", required=True)
+@click.pass_context
+def delete_license(ctx, license_id, **kwargs):
+    licenses.delete_license(ctx, license_id, **kwargs)
+
+
+@cmd.command(name="list-license-details")
+@click.option("--org-id", default=None)
+@click.option("--license-id", multiple=True, default=None)
+@click.option("--page-at-id", default=None)
+@click.option("--limit", default=500)
+@click.pass_context
+def list_license_details(ctx, license_id, **kwargs):
+    if not license_id:
+        license_id = None
+    result = licenses.list_license_details(ctx, license_ids=license_id, **kwargs)
+    table = licenses.format_license_details(ctx, result)
+    print(table)
+
+
+@cmd.command(name="list-license-evaluation-contexts")
+@click.option("--org-id", default=None)
+@click.option("--license-id", multiple=True, default=None)
+@click.option("--page-at-id", default=None)
+@click.option("--limit", default=500)
+@click.pass_context
+def list_license_evaluation_contexts(ctx, license_id, **kwargs):
+    if not license_id:
+        license_id = None
+    result = licenses.list_license_evaluation_contexts(
+        ctx, license_ids=license_id, **kwargs
+    )
+    table = licenses.format_license_evaluation_contexts(ctx, result)
+    print(table)
+
+
+def add_commands(cli):
+    cmd.add_to_cli(cli)