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

agilicus/resource_helpers.py

@@ -4,6 +4,13 @@ from agilicus.agilicus_api import (
     ResourceConfig,
 )
 
+standard_page_fields = [
+    "id",
+    "name",
+    "created",
+    "org_id",
+]
+
 
 def map_resource_published(mapping, published):
     if published is not None:

agilicus/resources.py

@@ -7,7 +7,7 @@ from .input_helpers import update_org_from_input_or_ctx, strip_none
 from .create import handle_api_409
 from agilicus.output.table import make_columns
 from . import resource_helpers
-
+from .pagination import normalize_page_args
 
 from .output.table import (
     subobject_column,
@@ -19,6 +19,7 @@ from .output.table import (
 )
 import agilicus
 
+
 permissioned_resource_types = [
     "application",
     "fileshare",
@@ -33,6 +34,10 @@ resource_types = permissioned_resource_types + ["service_forwarder"]
 permissioned_resource_type_enum = click.Choice(permissioned_resource_types)
 resource_type_enum = click.Choice(resource_types)
 
+resource_page_fields = resource_helpers.standard_page_fields + [
+    "resource_type",
+]
+
 
 def query_permissions(ctx, org_id=None, **kwargs):
     org_id = get_org_from_input_or_ctx(ctx, org_id=org_id)
@@ -108,17 +113,21 @@ def bulk_delete_permission(ctx, **kwargs):
     )
 
 
-def query_resources(ctx, org_id=None, **kwargs):
+def query_resources(ctx, org_id=None, get_all=False, limit=None, **kwargs):
     org_id = get_org_from_input_or_ctx(ctx, org_id=org_id)
     token = context.get_token(ctx)
     apiclient = context.get_apiclient(ctx, token)
     kwargs["org_id"] = org_id
     params = {}
     update_if_not_none(params, kwargs)
-    query_results = apiclient.resources_api.list_resources(**params)
-    if query_results:
-        return query_results.resources
-    return []
+    params = normalize_page_args(params)
+    if not get_all:
+        if limit is None:
+            limit = 500
+        return apiclient.resources_api.list_resources(limit=limit, **params).resources
+    return apiclient.resources_api.list_resources.auto_paging_iter(
+        limit=limit, **params
+    ).all()
 
 
 def format_resources(ctx, resources, show_columns=None, reset_columns=None):
@@ -220,6 +229,8 @@ def update_resource(
     rules_config_file=None,
     roles_config_file=None,
     published=None,
+    hide=None,
+    bundle_id=None,
     **kwargs,
 ):
     org_id = get_org_from_input_or_ctx(ctx, org_id=org_id)
@@ -236,6 +247,11 @@ def update_resource(
                 continue
             resource.spec.resource_members.append(member)
 
+    config = resource.spec.config
+    if config is None:
+        config = agilicus.ResourceConfig()
+        resource.spec.config = config
+
     if resource_members is not None:
         for member in resource_members:
             resource.spec.resource_members.append(agilicus.ResourceMember(id=member))
@@ -247,6 +263,15 @@ def update_resource(
         resource.spec.config.roles_config = roles_config_file
     if published is not None:
         resource.spec.config.published = published
+    if bundle_id is not None:
+        resource.spec.bundle_id = bundle_id
+
+    if hide:
+        display_info = config.display_info
+        if display_info is None:
+            display_info = agilicus.DisplayInfo(icons=[])
+            config.display_info = display_info
+        display_info.hide = hide
 
     return apiclient.resources_api.replace_resource(id, resource=resource).to_dict()
 

agilicus/rules/rules.py

@@ -29,6 +29,7 @@ ConditionTypes = Enum(
         "mfa_rule_condition",
         "scope_condition",
         "network_protocol_condition",
+        "compound_rule_condition",
     ],
 )
 
@@ -928,27 +929,77 @@ def add_network_protocol_condition_rule(
     standalone_rule_policy_id=None,
     **kwargs,
 ):
-    token = context.get_token(ctx)
-    apiclient = context.get_apiclient(ctx, token)
-    kwargs = strip_none(kwargs)
-
     cond = agilicus.NetworkProtocolCondition(
         condition_type=ConditionTypes.network_protocol_condition.name,
         protocol=protocol,
     )
-    extended_cond = agilicus.RuleCondition(condition=cond, negated=False)
+    return add_rule(
+        ctx,
+        name,
+        cond,
+        actions,
+        purpose=purpose,
+        protocol=protocol,
+        standalone_rule_policy_id=standalone_rule_policy_id,
+        **kwargs,
+    )
+
+
+def add_agilicus_default_expose_allow(
+    ctx,
+    label="agilicus-defaults-policy",
+    name="default_expose_network",
+    action="allow",
+    purpose=None,
+    **kwargs,
+):
+    add_network_protocol_condition_rule(
+        ctx,
+        name,
+        [action],
+        protocol="tcp",
+        **kwargs,
+    )
+    add_label(ctx, label=label, **kwargs)
+    add_rule_tree(ctx, name, children=[], rules=[name], **kwargs)
+    add_ruleset(ctx, name, trees=[name], labels=[label], **kwargs)
+
+
+def add_rule(
+    ctx,
+    name,
+    condition,
+    actions,
+    purpose=None,
+    comments=None,
+    roles=None,
+    scope=None,
+    standalone_rule_policy_id=None,
+    **kwargs,
+):
+    token = context.get_token(ctx)
+    apiclient = context.get_apiclient(ctx, token)
+    kwargs = strip_none(kwargs)
+
+    extended_cond = agilicus.RuleCondition(condition=condition, negated=False)
 
     rule = agilicus.RuleConfig(
         name=name,
         extended_condition=extended_cond,
         actions=[agilicus.RuleAction(action=action) for action in actions],
     )
+    if roles is not None:
+        rule.roles = roles
+    if scope is not None:
+        rule.scope = agilicus.RuleScopeEnum(scope)
 
     org_id = get_org_from_input_or_ctx(ctx, **kwargs)
     kwargs["org_id"] = org_id
     spec = agilicus.StandaloneRuleSpec(org_id=org_id, rule=rule)
     if purpose is not None:
         spec.purpose = purpose
+    if comments:
+        spec.comments = comments
 
     if standalone_rule_policy_id is not None:
         spec.standalone_rule_policy_id = standalone_rule_policy_id
@@ -964,24 +1015,47 @@ def add_network_protocol_condition_rule(
     return result
 
 
-def add_agilicus_default_expose_allow(
+def make_compound_condition(
+    conditions,
+    list_type="cnf",
+):
+    return agilicus.CompoundRuleCondition(
+        condition_type=ConditionTypes.compound_rule_condition.name,
+        condition_list=conditions,
+        list_type=list_type,
+    )
+
+
+def add_agilicus_default_database_allow(
     ctx,
     label="agilicus-defaults-policy",
-    name="default_expose_network",
+    name="default_database",
     action="allow",
-    purpose=None,
     **kwargs,
 ):
-    add_network_protocol_condition_rule(
+    # The database rule uses an empty cnf compound condition to match everything,
+    # subject to the scope and roles
+    condition = make_compound_condition([], list_type="cnf")
+    add_rule(
         ctx,
         name,
-        [action],
-        protocol="tcp",
+        condition=condition,
+        actions=[action],
+        roles=["owner"],
+        scope="assigned_to_user",
         **kwargs,
     )
     add_label(ctx, label=label, **kwargs)
     add_rule_tree(ctx, name, children=[], rules=[name], **kwargs)
-    add_ruleset(ctx, name, trees=[name], labels=[label], **kwargs)
+    # The scope here ensures this entire set of rules only applies to databases
+    add_ruleset(
+        ctx,
+        name,
+        trees=[name],
+        labels=[label],
+        scopes=["urn:agilicus:database:*"],
+        **kwargs,
+    )
 
 
 def add_agilicus_default_policy(
@@ -989,3 +1063,4 @@ def add_agilicus_default_policy(
     **kwargs,
 ):
     add_agilicus_default_expose_allow(ctx)
+    add_agilicus_default_database_allow(ctx)

agilicus/rules/rules_main.py

@@ -388,6 +388,13 @@ def cli_command_add_agilicus_default_expose_allow(ctx, **kwargs):
     rules.add_agilicus_default_expose_allow(ctx, **kwargs)
 
 
+@click.command(name="add-agilicus-default-policy")
+@click.option("--org-id", default=None)
+@click.pass_context
+def cli_command_add_agilicus_default_policy(ctx, **kwargs):
+    rules.add_agilicus_default_policy(ctx, **kwargs)
+
+
 @click.command(name="add-scope-condition-rule")
 @click.option("--name", required=True)
 @click.option("--action", required=True, multiple=True, type=click.Choice(rules.ACTIONS))

agilicus/ssh.py

@@ -15,15 +15,29 @@ 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_ssh_resources(ctx, **kwargs):
+
+def list_ssh_resources(ctx, get_all=False, limit=None, **kwargs):
     apiclient = context.get_apiclient_from_ctx(ctx)
     update_org_from_input_or_ctx(kwargs, ctx, **kwargs)
     params = strip_none(kwargs)
-    query_results = apiclient.app_services_api.list_ssh_resources(**params)
-    return query_results.ssh_resources
+    params = normalize_page_args(params)
+    if not get_all:
+        if limit is None:
+            limit = 500
+        return apiclient.app_services_api.list_ssh_resources(
+            limit=limit, **params
+        ).ssh_resources
+    return [
+        x
+        for x in apiclient.app_services_api.list_ssh_resources.auto_paging_iter(
+            limit=limit, **params
+        )
+    ]
 
 
 def add_ssh_resource(ctx, port, **kwargs):

agilicus/tests/pagination/test_auto_iterator.py

@@ -0,0 +1,340 @@
+import pytest
+from unittest.mock import Mock
+from agilicus.pagination.auto_iterator import (
+    AutoIterator,
+    AutoIteratorWrapper,
+    get_page_on,
+    _determine_page_on,
+    patch_endpoint,
+    _handle_page_failure,
+)
+from agilicus_api.exceptions import ApiException
+from agilicus import ListSSHResourcesResponse
+from agilicus_api.api_client import Endpoint
+
+
+class MockPageInfo:
+    def __init__(self, page_at_key, page_on_value):
+        self.page_at_key = page_at_key
+        self.page_on = Mock(value=page_on_value)
+
+
+class MockResponse:
+    def __init__(self, items, page_at_key=None, page_on_value=None):
+        self.items = items
+        self.attribute_map = {"items": "list[object]"}
+        self.page_info = (
+            MockPageInfo(page_at_key, page_on_value)
+            if page_at_key and page_on_value
+            else None
+        )
+
+    def get(self, key):
+        if key == "items":
+            return self.items
+        return None
+
+
+class MockItem:
+    def __init__(self, name, index):
+        self.name = name
+        self.id = index
+
+
+class MockListFunction:
+    def __init__(self, items_per_page, total_items, page_on_allowed=None):
+        self._all_items = [MockItem(f"item_{i}", i) for i in range(total_items)]
+        self._items_per_page = items_per_page
+        self.call_count = 0
+        self.allowed_values = {}
+        self.params_map = {"all": []}
+        if page_on_allowed is None:
+            page_on_allowed = ["id"]
+        if page_on_allowed:
+            self.allowed_values = {("page_on",): {k: k for k in page_on_allowed}}
+            self.params_map["all"].append("page_on")
+
+    def __call__(
+        self, page_on=None, page_at_key=None, limit=None, page_sort=None, **kwargs
+    ):
+        self.call_count += 1
+        start_index = 0
+        if page_at_key and page_at_key[0] is not None:
+            try:
+                start_index = len(self._all_items)
+                for idx, item in enumerate(self._all_items):
+                    compare_tuple = [getattr(item, key) for key in page_on]
+                    if page_at_key < compare_tuple:
+                        start_index = idx
+                        break
+            except ValueError:
+                start_index = len(self._all_items)
+
+        end_index = min(start_index + limit, len(self._all_items))
+        current_items = self._all_items[start_index:end_index]
+
+        next_page_at_key = None
+        if end_index < len(self._all_items):
+            next_page_at_key = [self._all_items[end_index - 1].id]
+
+        return MockResponse(
+            current_items,
+            page_at_key=next_page_at_key,
+            page_on_value=page_on if page_on else None,
+        )
+
+
+def test_auto_iterator_basic_pagination():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=5)
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+
+    items = list(iterator)
+    assert len(items) == 5
+    assert mock_list_function.call_count == 3  # 5 items, 2 per page = 3 calls (2,2,1)
+    assert [item.name for item in items] == [
+        "item_0",
+        "item_1",
+        "item_2",
+        "item_3",
+        "item_4",
+    ]
+
+
+def test_auto_iterator_with_limit():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=5)
+    iterator = AutoIterator(mock_list_function, limit=3, page_size=2, page_sort=[])
+
+    items = list(iterator)
+    assert len(items) == 3
+    assert mock_list_function.call_count == 2  # 3 items, 2 per page = 2 calls (2,1)
+    assert [item.name for item in items] == ["item_0", "item_1", "item_2"]
+
+
+def test_auto_iterator_empty_result():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=0)
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+
+    items = list(iterator)
+    assert len(items) == 0
+    assert mock_list_function.call_count == 1
+
+
+def test_auto_iterator_first_method():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=5)
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+
+    first_item = iterator.first()
+    assert first_item.name == "item_0"
+    assert mock_list_function.call_count == 1
+
+    # Calling first again should re-initialize and get the first item again
+    first_item = iterator.first()
+    assert first_item.name == "item_0"
+    assert mock_list_function.call_count == 2
+
+
+def test_auto_iterator_first_method_empty():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=0)
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+
+    first_item = iterator.first()
+    assert first_item is None
+    assert mock_list_function.call_count == 1
+
+
+def test_auto_iterator_all_method():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=5)
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+
+    all_items = iterator.all()
+    assert len(all_items) == 5
+    assert mock_list_function.call_count == 3
+    assert [item.name for item in all_items] == [
+        "item_0",
+        "item_1",
+        "item_2",
+        "item_3",
+        "item_4",
+    ]
+
+
+def test_auto_iterator_all_method_empty():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=0)
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+
+    all_items = iterator.all()
+    assert len(all_items) == 0
+    assert mock_list_function.call_count == 1
+
+
+def test_auto_iterator_wrapper():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=5)
+    wrapper = AutoIteratorWrapper(mock_list_function)
+    iterator = wrapper(limit=3, page_size=2, page_sort=["name"])
+
+    assert isinstance(iterator, AutoIterator)
+    assert iterator.limit == 3
+    assert iterator.page_size == 2
+    assert iterator.page_sort == ["name"]
+
+
+def test_get_page_on_with_allowed_values():
+    mock_list_function = Mock()
+    mock_list_function.allowed_values = {("page_on",): {"id": "id", "name": "name"}}
+    mock_list_function.params_map = {"all": ["page_on"]}
+    assert get_page_on(mock_list_function) == ["id", "name"]
+
+
+def test_get_page_on_without_allowed_values_but_in_params_map():
+    mock_list_function = Mock()
+    mock_list_function.allowed_values = {}
+    mock_list_function.params_map = {"all": ["page_on"]}
+    assert get_page_on(mock_list_function) == ["id"]
+
+
+def test_get_page_on_not_in_params_map():
+    mock_list_function = Mock()
+    mock_list_function.allowed_values = {}
+    mock_list_function.params_map = {"all": []}
+    assert get_page_on(mock_list_function) == []
+
+
+def test_determine_page_on_preference():
+    mock_list_function = Mock()
+    mock_list_function.allowed_values = {
+        ("page_on",): {"created": "created", "id": "id"}
+    }
+    mock_list_function.params_map = {"all": ["page_on"]}
+    assert _determine_page_on(mock_list_function) == ["created"]
+
+
+def test_determine_page_on_default():
+    mock_list_function = Mock()
+    mock_list_function.allowed_values = {("page_on",): {"foo": "foo"}}
+    mock_list_function.params_map = {"all": ["page_on"]}
+    assert _determine_page_on(mock_list_function) == ["foo"]
+
+
+def test_determine_page_on_not_implemented():
+    mock_list_function = Mock()
+    mock_list_function.allowed_values = {}
+    mock_list_function.params_map = {"all": []}
+    with pytest.raises(NotImplementedError):
+        _determine_page_on(mock_list_function)
+
+
+def test_patch_endpoint():
+    mock_list_function = Mock()
+    patch_endpoint(mock_list_function)
+    assert hasattr(mock_list_function, "auto_paging_iter")
+    assert isinstance(mock_list_function.auto_paging_iter, AutoIteratorWrapper)
+
+
+def test_handle_page_failure_pagination_key_error():
+    exc = ApiException(status=400, reason="Bad Request", http_resp=Mock())
+    exc.body = '{"error_message": "Invalid pagination key"}'
+    with pytest.raises(
+        NotImplementedError, match="Pagination not implemented on this key"
+    ):
+        _handle_page_failure(exc.body)
+
+
+def test_handle_page_failure_other_400_error():
+    exc = ApiException(status=400, reason="Bad Request", http_resp=Mock())
+    exc.body = '{"error_message": "Some other error"}'
+    with pytest.raises(ApiException):
+        try:
+            raise exc
+        except Exception as exc:
+            _handle_page_failure(exc.body)
+
+
+def test_handle_page_failure_no_body():
+    exc = ApiException(status=400, reason="Bad Request", http_resp=Mock())
+    exc.body = None
+    with pytest.raises(ApiException):
+        try:
+            raise exc
+        except Exception as exc:
+            _handle_page_failure(exc.body)
+
+
+def test_handle_page_failure_invalid_json():
+    exc = ApiException(status=400, reason="Bad Request", http_resp=Mock())
+    exc.body = "invalid json"
+    with pytest.raises(ApiException):
+        try:
+            raise exc
+        except Exception as exc:
+            _handle_page_failure(exc.body)
+
+
+def test_auto_iterator_api_exception_other_status():
+    mock_list_function = Mock()
+    mock_list_function.allowed_values = {("page_on",): {"foo": "foo"}}
+    mock_list_function.params_map = {"all": ["page_on"]}
+    mock_list_function.side_effect = ApiException(
+        status=500, reason="Internal Server Error"
+    )
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+
+    with pytest.raises(ApiException):
+        list(iterator)
+
+
+def test_auto_iterator_repr():
+    mock_list_function = Mock(
+        __name__="mock_list_function",
+        allowed_values={("page_on",): {"id": "id"}},
+        params_map={"all": ["page_on"]},
+    )
+    iterator = AutoIterator(mock_list_function, limit=None, page_size=2, page_sort=[])
+    assert repr(iterator) == "<AutoIterator for mock_list_function>"
+
+
+def test_auto_patch_endpoint():
+    mock_list_function = MockListFunction(items_per_page=2, total_items=5)
+
+    def wrap_list(*args, **kwargs):
+        return mock_list_function(**kwargs)
+
+    foo = Endpoint(
+        settings={
+            "response_type": (ListSSHResourcesResponse,),
+            "auth": ["token-valid"],
+            "endpoint_path": "/v1/ssh_resources",
+            "operation_id": "list_ssh_resources",
+            "http_method": "GET",
+            "servers": None,
+        },
+        params_map={
+            "all": [
+                "page_on",
+                "page_at_key",
+                "page_sort",
+                "search_direction",
+            ],
+            "required": [],
+            "nullable": [],
+            "enum": [
+                "page_sort",
+                "search_direction",
+            ],
+            "validation": [
+                "name",
+                "limit",
+            ],
+        },
+        root_map={
+            "validations": [],
+            "allowed_values": {("page_on,"): ["name"]},
+            "openapi_types": {},
+            "attribute_map": {},
+            "location_map": {},
+            "collection_format_map": {},
+        },
+        callable=wrap_list,
+    )
+
+    assert foo.auto_paging_iter is not None
+    assert next(foo.auto_paging_iter()).name == "item_0"

agilicus/tokens.py

@@ -47,6 +47,7 @@ def _create_token(
     scopes=None,
     inherit_session=False,
     create_refresh_token=None,
+    get_user=None,
 ):
     obj = agilicus.CreateTokenRequest(
         sub=user_id,
@@ -64,6 +65,9 @@ def _create_token(
     if create_refresh_token:
         obj.create_refresh_token = create_refresh_token
 
+    if get_user:
+        obj.get_user = get_user
+
     token = context.get_token(ctx)
     apiclient = context.get_apiclient(ctx, token)
     return apiclient.tokens_api.create_token(obj)