python3-core-api-client 0.1__py3-none-any.whl

cyberfusion/CoreApiClient/resources/__init__.py

@@ -0,0 +1,99 @@
+from . import (
+    borg_repositories,
+    databases,
+    daemons,
+    ssh_keys,
+    unix_users,
+    mail_aliases,
+    health,
+    malwares,
+    clusters,
+    task_collections,
+    htpasswd_users,
+    custom_config_snippets,
+    certificate_managers,
+    haproxy_listens,
+    certificates,
+    database_user_grants,
+    htpasswd_files,
+    url_redirects,
+    firewall_groups,
+    mariadb_encryption_keys,
+    virtual_hosts,
+    passenger_apps,
+    cmses,
+    redis_instances,
+    logs,
+    sites,
+    mail_hostnames,
+    domain_routers,
+    node_add_ons,
+    haproxy_listens_to_nodes,
+    ftp_users,
+    custom_configs,
+    borg_archives,
+    login,
+    crons,
+    nodes,
+    hosts_entries,
+    database_users,
+    security_txt_policies,
+    customers,
+    basic_authentication_realms,
+    root_ssh_keys,
+    firewall_rules,
+    mail_accounts,
+    fpm_pools,
+    mail_domains,
+    tombstones,
+)
+
+__all__ = [
+    "basic_authentication_realms",
+    "borg_archives",
+    "borg_repositories",
+    "certificate_managers",
+    "certificates",
+    "clusters",
+    "cmses",
+    "crons",
+    "custom_config_snippets",
+    "custom_configs",
+    "daemons",
+    "database_user_grants",
+    "database_users",
+    "databases",
+    "domain_routers",
+    "firewall_groups",
+    "firewall_rules",
+    "fpm_pools",
+    "ftp_users",
+    "haproxy_listens",
+    "haproxy_listens_to_nodes",
+    "health",
+    "hosts_entries",
+    "htpasswd_files",
+    "htpasswd_users",
+    "logs",
+    "mail_accounts",
+    "mail_aliases",
+    "mail_domains",
+    "mail_hostnames",
+    "malwares",
+    "mariadb_encryption_keys",
+    "nodes",
+    "node_add_ons",
+    "passenger_apps",
+    "redis_instances",
+    "root_ssh_keys",
+    "security_txt_policies",
+    "sites",
+    "ssh_keys",
+    "task_collections",
+    "tombstones",
+    "unix_users",
+    "url_redirects",
+    "virtual_hosts",
+    "login",
+    "customers",
+]

cyberfusion/CoreApiClient/resources/basic_authentication_realms.py

@@ -0,0 +1,85 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class BasicAuthenticationRealms(Resource):
+    def create_basic_authentication_realm(
+        self,
+        request: models.BasicAuthenticationRealmCreateRequest,
+    ) -> models.BasicAuthenticationRealmResource:
+        return models.BasicAuthenticationRealmResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/basic-authentication-realms",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_basic_authentication_realms(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.BasicAuthenticationRealmResource]:
+        return [
+            models.BasicAuthenticationRealmResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/basic-authentication-realms",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_basic_authentication_realm(
+        self,
+        *,
+        id_: int,
+    ) -> models.BasicAuthenticationRealmResource:
+        return models.BasicAuthenticationRealmResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/basic-authentication-realms/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )
+
+    def update_basic_authentication_realm(
+        self,
+        request: models.BasicAuthenticationRealmUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.BasicAuthenticationRealmResource:
+        return models.BasicAuthenticationRealmResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/basic-authentication-realms/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_basic_authentication_realm(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE",
+                f"/api/v1/basic-authentication-realms/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )

cyberfusion/CoreApiClient/resources/borg_archives.py

@@ -0,0 +1,144 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class BorgArchives(Resource):
+    def create_borg_archive_for_database(
+        self,
+        request: models.BorgArchiveCreateDatabaseRequest,
+        *,
+        callback_url: Optional[str] = None,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/borg-archives/database",
+                data=request.dict(),
+                query_parameters={
+                    "callback_url": callback_url,
+                },
+            ).json
+        )
+
+    def create_borg_archive_for_unix_user(
+        self,
+        request: models.BorgArchiveCreateUNIXUserRequest,
+        *,
+        callback_url: Optional[str] = None,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/borg-archives/unix-user",
+                data=request.dict(),
+                query_parameters={
+                    "callback_url": callback_url,
+                },
+            ).json
+        )
+
+    def list_borg_archives(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.BorgArchiveResource]:
+        return [
+            models.BorgArchiveResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/borg-archives",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_borg_archive(
+        self,
+        *,
+        id_: int,
+    ) -> models.BorgArchiveResource:
+        return models.BorgArchiveResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/borg-archives/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def get_borg_archive_metadata(
+        self,
+        *,
+        id_: int,
+    ) -> models.BorgArchiveMetadata:
+        return models.BorgArchiveMetadata.construct(
+            **self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/borg-archives/{id_}/metadata",
+                data=None,
+                query_parameters={},
+            ).json
+        )
+
+    def restore_borg_archive(
+        self,
+        *,
+        id_: int,
+        callback_url: Optional[str] = None,
+        path: Optional[str] = None,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                f"/api/v1/borg-archives/{id_}/restore",
+                data=None,
+                query_parameters={
+                    "callback_url": callback_url,
+                    "path": path,
+                },
+            ).json
+        )
+
+    def list_borg_archive_contents(
+        self,
+        *,
+        id_: int,
+        path: Optional[str] = None,
+    ) -> list[models.BorgArchiveContent]:
+        return [
+            models.BorgArchiveContent.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/borg-archives/{id_}/contents",
+                data=None,
+                query_parameters={
+                    "path": path,
+                },
+            ).json
+        ]
+
+    def download_borg_archive(
+        self,
+        *,
+        id_: int,
+        callback_url: Optional[str] = None,
+        path: Optional[str] = None,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                f"/api/v1/borg-archives/{id_}/download",
+                data=None,
+                query_parameters={
+                    "callback_url": callback_url,
+                    "path": path,
+                },
+            ).json
+        )

cyberfusion/CoreApiClient/resources/borg_repositories.py

@@ -0,0 +1,134 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class BorgRepositories(Resource):
+    def create_borg_repository(
+        self,
+        request: models.BorgRepositoryCreateRequest,
+    ) -> models.BorgRepositoryResource:
+        return models.BorgRepositoryResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/borg-repositories",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_borg_repositories(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.BorgRepositoryResource]:
+        return [
+            models.BorgRepositoryResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/borg-repositories",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_borg_repository(
+        self,
+        *,
+        id_: int,
+    ) -> models.BorgRepositoryResource:
+        return models.BorgRepositoryResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/borg-repositories/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )
+
+    def update_borg_repository(
+        self,
+        request: models.BorgRepositoryUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.BorgRepositoryResource:
+        return models.BorgRepositoryResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/borg-repositories/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_borg_repository(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE",
+                f"/api/v1/borg-repositories/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )
+
+    def prune_borg_repository(
+        self,
+        *,
+        id_: int,
+        callback_url: Optional[str] = None,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                f"/api/v1/borg-repositories/{id_}/prune",
+                data=None,
+                query_parameters={
+                    "callback_url": callback_url,
+                },
+            ).json
+        )
+
+    def check_borg_repository(
+        self,
+        *,
+        id_: int,
+        callback_url: Optional[str] = None,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                f"/api/v1/borg-repositories/{id_}/check",
+                data=None,
+                query_parameters={
+                    "callback_url": callback_url,
+                },
+            ).json
+        )
+
+    def get_borg_archives_metadata(
+        self,
+        *,
+        id_: int,
+    ) -> list[models.BorgArchiveMetadata]:
+        return [
+            models.BorgArchiveMetadata.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/borg-repositories/{id_}/archives-metadata",
+                data=None,
+                query_parameters={},
+            ).json
+        ]

cyberfusion/CoreApiClient/resources/certificate_managers.py

@@ -0,0 +1,99 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class CertificateManagers(Resource):
+    def create_certificate_manager(
+        self,
+        request: models.CertificateManagerCreateRequest,
+    ) -> models.CertificateManagerResource:
+        return models.CertificateManagerResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/certificate-managers",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_certificate_managers(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.CertificateManagerResource]:
+        return [
+            models.CertificateManagerResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/certificate-managers",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_certificate_manager(
+        self,
+        *,
+        id_: int,
+    ) -> models.CertificateManagerResource:
+        return models.CertificateManagerResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/certificate-managers/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )
+
+    def update_certificate_manager(
+        self,
+        request: models.CertificateManagerUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.CertificateManagerResource:
+        return models.CertificateManagerResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/certificate-managers/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_certificate_manager(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE",
+                f"/api/v1/certificate-managers/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )
+
+    def request_certificate(
+        self,
+        *,
+        id_: int,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                f"/api/v1/certificate-managers/{id_}/request",
+                data=None,
+                query_parameters={},
+            ).json
+        )

cyberfusion/CoreApiClient/resources/certificates.py

@@ -0,0 +1,63 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class Certificates(Resource):
+    def create_certificate(
+        self,
+        request: models.CertificateCreateRequest,
+    ) -> models.CertificateResource:
+        return models.CertificateResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/certificates",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_certificates(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.CertificateResource]:
+        return [
+            models.CertificateResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/certificates",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_certificate(
+        self,
+        *,
+        id_: int,
+    ) -> models.CertificateResource:
+        return models.CertificateResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/certificates/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def delete_certificate(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE", f"/api/v1/certificates/{id_}", data=None, query_parameters={}
+            ).json
+        )