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
|
from __future__ import annotations
from typing import TYPE_CHECKING
from dateutil.parser import isoparse
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 = isoparse(not_valid_before) if not_valid_before else None
self.not_valid_after = isoparse(not_valid_after) if not_valid_after else None
self.created = isoparse(created) if created else None
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
"""
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
"""
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
|
