cacholong-cloud-cli 0.3.0__py3-none-any.whl

cacholong_cli/commands/dns_records.py

@@ -0,0 +1,275 @@
+import asyncio
+import typer
+from typing import List, Optional
+from typing_extensions import Annotated
+from rich.table import Column
+from uuid import UUID
+from cacholong_cli.AsyncTyper import AsyncTyper
+from cacholong_cli.common import (
+    list_resources,
+    list_relation_resources,
+    show_resource,
+    print_document_error,
+)
+from cacholong_cli.connection import Connection
+from cacholong_sdk import Filter, Inclusion, DocumentError, ResourceTuple
+from cacholong_sdk import DnsRecord, DnsRecordModel
+
+# Create typer object
+app = AsyncTyper()
+
+
+@app.async_command()
+async def list(
+    ctx: typer.Context,
+    external_service_provider_status: Annotated[
+        Optional[str], typer.Option(help="Status for external service provider.")
+    ] = None,
+    dns_record_type: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Depending on DNS record type name, content, ttl and priority will be validated. Only record types mentioned are allowed and NS record type is only available for certain users."
+        ),
+    ] = None,
+    name: Annotated[
+        Optional[str],
+        typer.Option(
+            help="For most records this must be a valid domain (SRV, TLSA and NS records follow different rules). When dns template is given, placeholder $domain$ must be used. When dns zone is given, name must be identical to dns zone domain fqdn. It is not allowed to end the name with a point."
+        ),
+    ] = None,
+    content: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Content differs for each DNS record type. When dns template is given, placeholder $domain$ is allowed for some records (for example CAA or CNAME records). Only TXT records can be longer then 255 chars."
+        ),
+    ] = None,
+    ttl: Annotated[
+        Optional[str],
+        typer.Option(
+            help='Time to live in seconds, limited to allowed values. Please note that a TTL of 1 (one) can have a special meaning (Cloudflare considers this value "automatic").'
+        ),
+    ] = None,
+    priority: Annotated[
+        Optional[str], typer.Option(help="Prohibited, except for MX and SRV record.")
+    ] = None,
+    created_at: Annotated[Optional[str], typer.Option(help="")] = None,
+    updated_at: Annotated[Optional[str], typer.Option(help="")] = None,
+    dns_zone: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing dns zone. Required unless dns template is given. Only available for certain users, dnz zone should not be administratively disabled. Must be unique with type, name, content and priority."
+        ),
+    ] = None,
+    dns_template: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing dns template. Required unless dns zone is given. Must be unique with type, name, content and priority."
+        ),
+    ] = None,
+):
+    # Build modifier
+    modifier = []
+    if external_service_provider_status is not None:
+        modifier.append(
+            Filter(
+                query_str="filter[external_service_provider_status]="
+                + str(external_service_provider_status)
+            )
+        )
+    if dns_record_type is not None:
+        modifier.append(
+            Filter(query_str="filter[dns_record_type]=" + str(dns_record_type))
+        )
+    if name is not None:
+        modifier.append(Filter(name=name))
+    if content is not None:
+        modifier.append(Filter(content=content))
+    if ttl is not None:
+        modifier.append(Filter(ttl=ttl))
+    if priority is not None:
+        modifier.append(Filter(priority=priority))
+    if created_at is not None:
+        modifier.append(Filter(query_str="filter[created_at]=" + str(created_at)))
+    if updated_at is not None:
+        modifier.append(Filter(query_str="filter[updated_at]=" + str(updated_at)))
+    if dns_zone is not None:
+        modifier.append(Filter(query_str="filter[dns-zone]=" + str(dns_zone)))
+    if dns_template is not None:
+        modifier.append(Filter(query_str="filter[dns-template]=" + str(dns_template)))
+
+    # Table definition
+    tabledef = [
+        {"header": Column("Id", no_wrap=True), "column": "id"},
+        {"header": "Name", "column": "name"},
+        {"header": "Dns record type", "column": "dns_record_type"},
+        {"header": "Content", "column": "content"},
+        {
+            "header": "External service provider status",
+            "column": "external_service_provider_status",
+        },
+        {"header": "Created", "column": "created_at"},
+        {"header": "Updated", "column": "updated_at"},
+    ]
+    async with Connection() as conn:
+        await list_resources(ctx, DnsRecord(conn), tabledef, modifier)
+
+
+@app.async_command()
+async def show(
+    ctx: typer.Context,
+    dns_record_id: Annotated[UUID, typer.Argument()],
+):
+    # Show resource
+    try:
+        async with Connection() as conn:
+            ctrl = DnsRecord(conn)
+            model = await ctrl.fetch(dns_record_id)
+
+            show_resource(ctx, model)
+    except DocumentError as e:
+        await print_document_error(e)
+
+
+@app.async_command()
+async def create(
+    ctx: typer.Context,
+    dns_record_type: Annotated[
+        str,
+        typer.Option(
+            help="Depending on DNS record type name, content, ttl and priority will be validated. Only record types mentioned are allowed and NS record type is only available for certain users."
+        ),
+    ],
+    name: Annotated[
+        str,
+        typer.Option(
+            help="For most records this must be a valid domain (SRV, TLSA and NS records follow different rules). When dns template is given, placeholder $domain$ must be used. When dns zone is given, name must be identical to dns zone domain fqdn. It is not allowed to end the name with a point."
+        ),
+    ],
+    content: Annotated[
+        str,
+        typer.Option(
+            help="Content differs for each DNS record type. When dns template is given, placeholder $domain$ is allowed for some records (for example CAA or CNAME records). Only TXT records can be longer then 255 chars."
+        ),
+    ],
+    ttl: Annotated[
+        Optional[int],
+        typer.Option(
+            help='Time to live in seconds, limited to allowed values. Please note that a TTL of 1 (one) can have a special meaning (Cloudflare considers this value "automatic").'
+        ),
+    ] = None,
+    priority: Annotated[
+        Optional[int], typer.Option(help="Prohibited, except for MX and SRV record.")
+    ] = None,
+    dns_zone: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing dns zone. Required unless dns template is given. Only available for certain users, dnz zone should not be administratively disabled. Must be unique with type, name, content and priority."
+        ),
+    ] = None,
+    dns_template: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing dns template. Required unless dns zone is given. Must be unique with type, name, content and priority."
+        ),
+    ] = None,
+):
+    try:
+        async with Connection() as conn:
+            ctrl = DnsRecord(conn)
+            model = ctrl.create()
+            model["dns_record_type"] = dns_record_type
+            model["name"] = name
+            model["content"] = content
+            if ttl is not None:
+                model["ttl"] = ttl
+            if priority is not None:
+                model["priority"] = priority
+            if dns_zone is not None:
+                model["dns-zone"] = ResourceTuple(dns_zone, "dns-zones")
+            if dns_template is not None:
+                model["dns-template"] = ResourceTuple(dns_template, "dns-templates")
+            await ctrl.store(model, ctx.obj["create_issue"])
+
+            show_resource(ctx, model)
+    except DocumentError as e:
+        await print_document_error(e)
+
+
+@app.async_command()
+async def update(
+    ctx: typer.Context,
+    dns_record_id: Annotated[UUID, typer.Argument()],
+    dns_record_type: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Depending on DNS record type name, content, ttl and priority will be validated. Only record types mentioned are allowed and NS record type is only available for certain users."
+        ),
+    ] = None,
+    name: Annotated[
+        Optional[str],
+        typer.Option(
+            help="For most records this must be a valid domain (SRV, TLSA and NS records follow different rules). When dns template is given, placeholder $domain$ must be used. When dns zone is given, name must be identical to dns zone domain fqdn. It is not allowed to end the name with a point."
+        ),
+    ] = None,
+    content: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Content differs for each DNS record type. When dns template is given, placeholder $domain$ is allowed for some records (for example CAA or CNAME records). Only TXT records can be longer then 255 chars."
+        ),
+    ] = None,
+    ttl: Annotated[
+        Optional[int],
+        typer.Option(
+            help='Time to live in seconds, limited to allowed values. Please note that a TTL of 1 (one) can have a special meaning (Cloudflare considers this value "automatic").'
+        ),
+    ] = None,
+    priority: Annotated[
+        Optional[int], typer.Option(help="Prohibited, except for MX and SRV record.")
+    ] = None,
+    dns_zone: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing dns zone. Required unless dns template is given. Only available for certain users, dnz zone should not be administratively disabled. Must be unique with type, name, content and priority."
+        ),
+    ] = None,
+    dns_template: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing dns template. Required unless dns zone is given. Must be unique with type, name, content and priority."
+        ),
+    ] = None,
+):
+    try:
+        async with Connection() as conn:
+            ctrl = DnsRecord(conn)
+            model = await ctrl.fetch(dns_record_id)
+            if dns_record_type is not None:
+                model["dns_record_type"] = dns_record_type
+            if name is not None:
+                model["name"] = name
+            if content is not None:
+                model["content"] = content
+            if ttl is not None:
+                model["ttl"] = ttl
+            if priority is not None:
+                model["priority"] = priority
+            if dns_zone is not None:
+                model["dns-zone"].set(dns_zone, "dns-zones")
+            if dns_template is not None:
+                model["dns-template"].set(dns_template, "dns-templates")
+    except DocumentError as e:
+        await print_document_error(e)
+
+
+@app.async_command()
+async def delete(
+    ctx: typer.Context,
+    dns_record_id: Annotated[List[UUID], typer.Argument()],
+):
+    try:
+        async with Connection() as conn, asyncio.TaskGroup() as tg:
+            ctrl = DnsRecord(conn)
+            for resource_id in dns_record_id:
+                tg.create_task(ctrl.destroy(resource_id))
+    except DocumentError as e:
+        await print_document_error(e)

cacholong_cli/commands/dns_templates.py

@@ -0,0 +1,141 @@
+import asyncio
+import typer
+from typing import List, Optional
+from typing_extensions import Annotated
+from rich.table import Column
+from uuid import UUID
+from cacholong_cli.AsyncTyper import AsyncTyper
+from cacholong_cli.common import (
+    list_resources,
+    list_relation_resources,
+    show_resource,
+    print_document_error,
+)
+from cacholong_cli.connection import Connection
+from cacholong_sdk import Filter, Inclusion, DocumentError, ResourceTuple
+from cacholong_sdk import DnsTemplate, DnsTemplateModel
+
+# Create typer object
+app = AsyncTyper()
+
+
+@app.async_command()
+async def list(
+    ctx: typer.Context,
+    name: Annotated[
+        Optional[str], typer.Option(help="Must be unique or unique with given account.")
+    ] = None,
+    created_at: Annotated[Optional[str], typer.Option(help="")] = None,
+    updated_at: Annotated[Optional[str], typer.Option(help="")] = None,
+    account: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing account. Some users can set this to null, meaning template is not limited to an account."
+        ),
+    ] = None,
+):
+    # Build modifier
+    modifier = []
+    if name is not None:
+        modifier.append(Filter(name=name))
+    if created_at is not None:
+        modifier.append(Filter(query_str="filter[created_at]=" + str(created_at)))
+    if updated_at is not None:
+        modifier.append(Filter(query_str="filter[updated_at]=" + str(updated_at)))
+    if account is not None:
+        modifier.append(Filter(account=str(account)))
+    modifier.append(Inclusion("account"))
+
+    # Table definition
+    tabledef = [
+        {"header": Column("Id", no_wrap=True), "column": "id"},
+        {"header": "Account", "column": "account", "nested_column": "name"},
+        {"header": "Name", "column": "name"},
+        {"header": "Created", "column": "created_at"},
+        {"header": "Updated", "column": "updated_at"},
+    ]
+    async with Connection() as conn:
+        await list_resources(ctx, DnsTemplate(conn), tabledef, modifier)
+
+
+@app.async_command()
+async def show(
+    ctx: typer.Context,
+    dns_template_id: Annotated[UUID, typer.Argument()],
+):
+    # Show resource
+    try:
+        async with Connection() as conn:
+            ctrl = DnsTemplate(conn)
+            model = await ctrl.fetch(dns_template_id)
+
+            show_resource(ctx, model)
+    except DocumentError as e:
+        await print_document_error(e)
+
+
+@app.async_command()
+async def create(
+    ctx: typer.Context,
+    name: Annotated[
+        str, typer.Option(help="Must be unique or unique with given account.")
+    ],
+    account: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing account. Some users can set this to null, meaning template is not limited to an account."
+        ),
+    ] = None,
+):
+    try:
+        async with Connection() as conn:
+            ctrl = DnsTemplate(conn)
+            model = ctrl.create()
+            model["name"] = name
+            if account is not None:
+                model["account"] = ResourceTuple(account, "accounts")
+            await ctrl.store(model, ctx.obj["create_issue"])
+
+            show_resource(ctx, model)
+    except DocumentError as e:
+        await print_document_error(e)
+
+
+@app.async_command()
+async def update(
+    ctx: typer.Context,
+    dns_template_id: Annotated[UUID, typer.Argument()],
+    name: Annotated[
+        Optional[str], typer.Option(help="Must be unique or unique with given account.")
+    ] = None,
+    account: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing account. Some users can set this to null, meaning template is not limited to an account."
+        ),
+    ] = None,
+):
+    try:
+        async with Connection() as conn:
+            ctrl = DnsTemplate(conn)
+            model = await ctrl.fetch(dns_template_id)
+            if name is not None:
+                model["name"] = name
+            if account is not None:
+                model["account"].set(account, "accounts")
+    except DocumentError as e:
+        await print_document_error(e)
+
+
+@app.async_command()
+async def delete(
+    ctx: typer.Context,
+    dns_template_id: Annotated[List[UUID], typer.Argument()],
+):
+    try:
+        async with Connection() as conn, asyncio.TaskGroup() as tg:
+            ctrl = DnsTemplate(conn)
+            for resource_id in dns_template_id:
+                tg.create_task(ctrl.destroy(resource_id))
+    except DocumentError as e:
+        await print_document_error(e)

cacholong_cli/commands/dns_zones.py

@@ -0,0 +1,277 @@
+import asyncio
+import typer
+from typing import List, Optional
+from typing_extensions import Annotated
+from rich.table import Column
+from uuid import UUID
+from cacholong_cli.AsyncTyper import AsyncTyper
+from cacholong_cli.common import (
+    list_resources,
+    list_relation_resources,
+    show_resource,
+    print_document_error,
+)
+from cacholong_cli.connection import Connection
+from cacholong_sdk import Filter, Inclusion, DocumentError, ResourceTuple
+from cacholong_sdk import DnsZone, DnsZoneModel
+
+# Create typer object
+app = AsyncTyper()
+
+
+@app.async_command()
+async def list(
+    ctx: typer.Context,
+    external_service_provider_status: Annotated[
+        Optional[str], typer.Option(help="Status for external service provider.")
+    ] = None,
+    domain: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Valid when provided with a domain and TLD (without a protocol)."
+        ),
+    ] = None,
+    active: Annotated[
+        Optional[str], typer.Option(help="Is dns zone active or not?")
+    ] = None,
+    administratively_disabled: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Is dns zone administratively disabled or not? Only visible for certain users."
+        ),
+    ] = None,
+    dnssec: Annotated[
+        Optional[str], typer.Option(help="Is dnssec enabled or not?")
+    ] = None,
+    dnssec_status: Annotated[
+        Optional[str], typer.Option(help="Status of DNSSEC.")
+    ] = None,
+    dnssec_flags: Annotated[
+        Optional[str], typer.Option(help="Flag for DNSSEC record.")
+    ] = None,
+    dnssec_algorithm: Annotated[
+        Optional[str], typer.Option(help="Algorithm key code.")
+    ] = None,
+    dnssec_public_key: Annotated[
+        Optional[str], typer.Option(help="Public key for DS record.")
+    ] = None,
+    created_at: Annotated[Optional[str], typer.Option(help="")] = None,
+    updated_at: Annotated[Optional[str], typer.Option(help="")] = None,
+    account: Annotated[
+        Optional[UUID], typer.Option(help="Account for this dns zone.")
+    ] = None,
+    name_server_group: Annotated[
+        Optional[UUID],
+        typer.Option(help="Name server groups for this dns zone. Readonly."),
+    ] = None,
+    purchase: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Purchase for this dns zone. Required if no product is provided."
+        ),
+    ] = None,
+    product: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Product for this dns zone. Required if no purchase is provided."
+        ),
+    ] = None,
+):
+    # Build modifier
+    modifier = []
+    if external_service_provider_status is not None:
+        modifier.append(
+            Filter(
+                query_str="filter[external_service_provider_status]="
+                + str(external_service_provider_status)
+            )
+        )
+    if domain is not None:
+        modifier.append(Filter(domain=domain))
+    if active is not None:
+        modifier.append(Filter(active=active))
+    if administratively_disabled is not None:
+        modifier.append(
+            Filter(
+                query_str="filter[administratively_disabled]="
+                + str(administratively_disabled)
+            )
+        )
+    if dnssec is not None:
+        modifier.append(Filter(dnssec=dnssec))
+    if dnssec_status is not None:
+        modifier.append(Filter(query_str="filter[dnssec_status]=" + str(dnssec_status)))
+    if dnssec_flags is not None:
+        modifier.append(Filter(query_str="filter[dnssec_flags]=" + str(dnssec_flags)))
+    if dnssec_algorithm is not None:
+        modifier.append(
+            Filter(query_str="filter[dnssec_algorithm]=" + str(dnssec_algorithm))
+        )
+    if dnssec_public_key is not None:
+        modifier.append(
+            Filter(query_str="filter[dnssec_public_key]=" + str(dnssec_public_key))
+        )
+    if created_at is not None:
+        modifier.append(Filter(query_str="filter[created_at]=" + str(created_at)))
+    if updated_at is not None:
+        modifier.append(Filter(query_str="filter[updated_at]=" + str(updated_at)))
+    if account is not None:
+        modifier.append(Filter(account=str(account)))
+    if name_server_group is not None:
+        modifier.append(
+            Filter(query_str="filter[name-server-group]=" + str(name_server_group))
+        )
+    if purchase is not None:
+        modifier.append(Filter(purchase=str(purchase)))
+    if product is not None:
+        modifier.append(Filter(product=str(product)))
+    modifier.append(Inclusion("account"))
+
+    # Table definition
+    tabledef = [
+        {"header": Column("Id", no_wrap=True), "column": "id"},
+        {"header": "Account", "column": "account", "nested_column": "name"},
+        {"header": "Domain", "column": "domain"},
+        {"header": "Active", "column": "active"},
+        {"header": "Dnssec", "column": "dnssec"},
+        {
+            "header": "External service provider status",
+            "column": "external_service_provider_status",
+        },
+        {"header": "Created", "column": "created_at"},
+        {"header": "Updated", "column": "updated_at"},
+    ]
+    async with Connection() as conn:
+        await list_resources(ctx, DnsZone(conn), tabledef, modifier)
+
+
+@app.async_command()
+async def show(
+    ctx: typer.Context,
+    dns_zone_id: Annotated[UUID, typer.Argument()],
+):
+    # Show resource
+    try:
+        async with Connection() as conn:
+            ctrl = DnsZone(conn)
+            model = await ctrl.fetch(dns_zone_id)
+
+            show_resource(ctx, model)
+    except DocumentError as e:
+        await print_document_error(e)
+
+
+@app.async_command()
+async def create(
+    ctx: typer.Context,
+    domain: Annotated[
+        str,
+        typer.Option(
+            help="Valid when provided with a domain and TLD (without a protocol)."
+        ),
+    ],
+    account: Annotated[UUID, typer.Option(help="Account for this dns zone.")],
+    active: Annotated[
+        Optional[bool], typer.Option(help="Is dns zone active or not?")
+    ] = None,
+    dnssec: Annotated[
+        Optional[bool], typer.Option(help="Is dnssec enabled or not?")
+    ] = None,
+    purchase: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Purchase for this dns zone. Required if no product is provided."
+        ),
+    ] = None,
+    product: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Product for this dns zone. Required if no purchase is provided."
+        ),
+    ] = None,
+):
+    try:
+        async with Connection() as conn:
+            ctrl = DnsZone(conn)
+            model = ctrl.create()
+            model["domain"] = domain
+            if active is not None:
+                model["active"] = active
+            if dnssec is not None:
+                model["dnssec"] = dnssec
+            model["account"] = ResourceTuple(account, "accounts")
+            if purchase is not None:
+                model["purchase"] = ResourceTuple(purchase, "purchases")
+            if product is not None:
+                model["product"] = ResourceTuple(product, "products")
+            await ctrl.store(model, ctx.obj["create_issue"])
+
+            show_resource(ctx, model)
+    except DocumentError as e:
+        await print_document_error(e)
+
+
+@app.async_command()
+async def update(
+    ctx: typer.Context,
+    dns_zone_id: Annotated[UUID, typer.Argument()],
+    domain: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Valid when provided with a domain and TLD (without a protocol)."
+        ),
+    ] = None,
+    active: Annotated[
+        Optional[bool], typer.Option(help="Is dns zone active or not?")
+    ] = None,
+    dnssec: Annotated[
+        Optional[bool], typer.Option(help="Is dnssec enabled or not?")
+    ] = None,
+    account: Annotated[
+        Optional[UUID], typer.Option(help="Account for this dns zone.")
+    ] = None,
+    purchase: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Purchase for this dns zone. Required if no product is provided."
+        ),
+    ] = None,
+    product: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Product for this dns zone. Required if no purchase is provided."
+        ),
+    ] = None,
+):
+    try:
+        async with Connection() as conn:
+            ctrl = DnsZone(conn)
+            model = await ctrl.fetch(dns_zone_id)
+            if domain is not None:
+                model["domain"] = domain
+            if active is not None:
+                model["active"] = active
+            if dnssec is not None:
+                model["dnssec"] = dnssec
+            if account is not None:
+                model["account"].set(account, "accounts")
+            if purchase is not None:
+                model["purchase"].set(purchase, "purchases")
+            if product is not None:
+                model["product"].set(product, "products")
+    except DocumentError as e:
+        await print_document_error(e)
+
+
+@app.async_command()
+async def delete(
+    ctx: typer.Context,
+    dns_zone_id: Annotated[List[UUID], typer.Argument()],
+):
+    try:
+        async with Connection() as conn, asyncio.TaskGroup() as tg:
+            ctrl = DnsZone(conn)
+            for resource_id in dns_zone_id:
+                tg.create_task(ctrl.destroy(resource_id))
+    except DocumentError as e:
+        await print_document_error(e)