hcloud-python/hcloud/certificates/domain.py at 5e9c0f5076a2da211473b0b85992c2c1e24f6851 · hetznercloud/hcloud-python · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
from __future__ import annotations

from typing import TYPE_CHECKING

from ..core import BaseDomain, DomainIdentityMixin

if TYPE_CHECKING:
    from ..actions import BoundAction
    from .client import BoundCertificate


class Certificate(BaseDomain, DomainIdentityMixin):
    """Certificate Domain

    :param id: int ID of Certificate
    :param name: str Name of Certificate
    :param certificate: str Certificate and chain in PEM format, in order so that each record directly certifies the one preceding
    :param not_valid_before: datetime
           Point in time when the Certificate becomes valid
    :param not_valid_after: datetime
           Point in time when the Certificate becomes invalid
    :param domain_names: List[str] List of domains and subdomains covered by this certificate
    :param fingerprint: str Fingerprint of the Certificate
    :param labels: dict
           User-defined labels (key-value pairs)
    :param created: datetime
           Point in time when the certificate was created
    :param type: str Type of Certificate
    :param status: ManagedCertificateStatus Current status of a type managed Certificate, always none for type uploaded Certificates
    """

    __api_properties__ = (
        "id",
        "name",
        "certificate",
        "not_valid_before",
        "not_valid_after",
        "domain_names",
        "fingerprint",
        "created",
        "labels",
        "type",
        "status",
    )
    __slots__ = __api_properties__

    TYPE_UPLOADED = "uploaded"
    TYPE_MANAGED = "managed"

    def __init__(
        self,
        id: int | None = None,
        name: str | None = None,
        certificate: str | None = None,
        not_valid_before: str | None = None,
        not_valid_after: str | None = None,
        domain_names: list[str] | None = None,
        fingerprint: str | None = None,
        created: str | None = None,
        labels: dict[str, str] | None = None,
        type: str | None = None,
        status: ManagedCertificateStatus | None = None,
    ):
        self.id = id
        self.name = name
        self.type = type
        self.certificate = certificate
        self.domain_names = domain_names
        self.fingerprint = fingerprint
        self.not_valid_before = self._parse_datetime(not_valid_before)
        self.not_valid_after = self._parse_datetime(not_valid_after)
        self.created = self._parse_datetime(created)
        self.labels = labels
        self.status = status


class ManagedCertificateStatus(BaseDomain):
    """ManagedCertificateStatus Domain

    :param issuance: str
           Status of the issuance process of the Certificate
    :param renewal: str
           Status of the renewal process of the Certificate
    :param error: ManagedCertificateError
          If issuance or renewal reports failure, this property contains information about what happened
    """

    __api_properties__ = (
        "issuance",
        "renewal",
        "error",
    )
    __slots__ = __api_properties__

    def __init__(
        self,
        issuance: str | None = None,
        renewal: str | None = None,
        error: ManagedCertificateError | None = None,
    ):
        self.issuance = issuance
        self.renewal = renewal
        self.error = error


class ManagedCertificateError(BaseDomain):
    """ManagedCertificateError Domain

    :param code: str
        Error code identifying the error
    :param message:
        Message detailing the error
    """

    __api_properties__ = (
        "code",
        "message",
    )
    __slots__ = __api_properties__

    def __init__(self, code: str | None = None, message: str | None = None):
        self.code = code
        self.message = message


class CreateManagedCertificateResponse(BaseDomain):
    """Create Managed Certificate Response Domain

    :param certificate: :class:`BoundCertificate <hcloud.certificate.client.BoundCertificate>`
           The created server
    :param action: :class:`BoundAction <hcloud.actions.client.BoundAction>`
           Shows the progress of the certificate creation
    """

    __api_properties__ = ("certificate", "action")
    __slots__ = __api_properties__

    def __init__(
        self,
        certificate: BoundCertificate,
        action: BoundAction,
    ):
        self.certificate = certificate
        self.action = action