donazopy 1.0.10__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- donazopy/__init__.py +11 -0
- donazopy/__main__.py +15 -0
- donazopy/_version.py +24 -0
- donazopy/cli.py +305 -0
- donazopy/models.py +29 -0
- donazopy/providers/__init__.py +6 -0
- donazopy/providers/aws.py +12 -0
- donazopy/providers/azure.py +12 -0
- donazopy/providers/base.py +211 -0
- donazopy/providers/bluehost.py +12 -0
- donazopy/providers/cloudflare.py +231 -0
- donazopy/providers/digitalocean.py +12 -0
- donazopy/providers/dnsimple.py +12 -0
- donazopy/providers/dynadot.py +14 -0
- donazopy/providers/gandi.py +14 -0
- donazopy/providers/godaddy.py +205 -0
- donazopy/providers/google_cloud.py +12 -0
- donazopy/providers/hetzner.py +12 -0
- donazopy/providers/hosting_com.py +12 -0
- donazopy/providers/hostinger.py +12 -0
- donazopy/providers/ionos.py +209 -0
- donazopy/providers/joker.py +215 -0
- donazopy/providers/linode.py +12 -0
- donazopy/providers/namecheap.py +12 -0
- donazopy/providers/porkbun.py +14 -0
- donazopy/providers/registry.py +66 -0
- donazopy/providers/vercel.py +12 -0
- donazopy/providers/vultr.py +14 -0
- donazopy/target.py +238 -0
- donazopy/zonefile.py +406 -0
- donazopy-1.0.10.dist-info/METADATA +400 -0
- donazopy-1.0.10.dist-info/RECORD +35 -0
- donazopy-1.0.10.dist-info/WHEEL +4 -0
- donazopy-1.0.10.dist-info/entry_points.txt +2 -0
- donazopy-1.0.10.dist-info/licenses/LICENSE +201 -0
donazopy/__init__.py
ADDED
|
@@ -0,0 +1,11 @@
|
|
|
1
|
+
# this_file: src/donazopy/__init__.py
|
|
2
|
+
"""DNS and domain-provider management CLI package."""
|
|
3
|
+
|
|
4
|
+
from importlib.metadata import PackageNotFoundError, version
|
|
5
|
+
|
|
6
|
+
try:
|
|
7
|
+
__version__ = version("donazopy")
|
|
8
|
+
except PackageNotFoundError:
|
|
9
|
+
__version__ = "0.0.0"
|
|
10
|
+
|
|
11
|
+
__all__ = ["__version__"]
|
donazopy/__main__.py
ADDED
|
@@ -0,0 +1,15 @@
|
|
|
1
|
+
# this_file: src/donazopy/__main__.py
|
|
2
|
+
"""Command-line entry point for donazopy."""
|
|
3
|
+
|
|
4
|
+
import fire
|
|
5
|
+
|
|
6
|
+
from donazopy.cli import Donazopy
|
|
7
|
+
|
|
8
|
+
|
|
9
|
+
def main() -> None:
|
|
10
|
+
"""Run the Fire-powered donazopy CLI."""
|
|
11
|
+
fire.Fire(Donazopy)
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
if __name__ == "__main__":
|
|
15
|
+
main()
|
donazopy/_version.py
ADDED
|
@@ -0,0 +1,24 @@
|
|
|
1
|
+
# file generated by vcs-versioning
|
|
2
|
+
# don't change, don't track in version control
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
__all__ = [
|
|
6
|
+
"__version__",
|
|
7
|
+
"__version_tuple__",
|
|
8
|
+
"version",
|
|
9
|
+
"version_tuple",
|
|
10
|
+
"__commit_id__",
|
|
11
|
+
"commit_id",
|
|
12
|
+
]
|
|
13
|
+
|
|
14
|
+
version: str
|
|
15
|
+
__version__: str
|
|
16
|
+
__version_tuple__: tuple[int | str, ...]
|
|
17
|
+
version_tuple: tuple[int | str, ...]
|
|
18
|
+
commit_id: str | None
|
|
19
|
+
__commit_id__: str | None
|
|
20
|
+
|
|
21
|
+
__version__ = version = '1.0.10'
|
|
22
|
+
__version_tuple__ = version_tuple = (1, 0, 10)
|
|
23
|
+
|
|
24
|
+
__commit_id__ = commit_id = None
|
donazopy/cli.py
ADDED
|
@@ -0,0 +1,305 @@
|
|
|
1
|
+
# this_file: src/donazopy/cli.py
|
|
2
|
+
"""Fire-powered donazopy CLI built around the unified target notation."""
|
|
3
|
+
|
|
4
|
+
from __future__ import annotations
|
|
5
|
+
|
|
6
|
+
from collections.abc import Callable, Mapping
|
|
7
|
+
from pathlib import Path
|
|
8
|
+
|
|
9
|
+
from donazopy import __version__
|
|
10
|
+
from donazopy.providers.base import (
|
|
11
|
+
DNSHostingProvider,
|
|
12
|
+
ProviderAPIError,
|
|
13
|
+
RegistrarProvider,
|
|
14
|
+
credential_status,
|
|
15
|
+
require_provider_credentials,
|
|
16
|
+
)
|
|
17
|
+
from donazopy.providers.registry import (
|
|
18
|
+
create_dns_provider,
|
|
19
|
+
create_registrar_provider,
|
|
20
|
+
get_provider,
|
|
21
|
+
list_providers,
|
|
22
|
+
)
|
|
23
|
+
from donazopy.target import Target, TargetError, looks_like_path, parse_target, resolve_provider_key
|
|
24
|
+
from donazopy.zonefile import (
|
|
25
|
+
diff_zone_records,
|
|
26
|
+
filter_zone_text,
|
|
27
|
+
normalize_zone_file,
|
|
28
|
+
records_from_zone_file,
|
|
29
|
+
records_from_zone_text,
|
|
30
|
+
validate_zone_file,
|
|
31
|
+
write_text_safely,
|
|
32
|
+
)
|
|
33
|
+
|
|
34
|
+
DnsFactory = Callable[..., DNSHostingProvider]
|
|
35
|
+
RegistrarFactory = Callable[..., RegistrarProvider]
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
def _operational_keys() -> tuple[str, ...]:
|
|
39
|
+
return tuple(provider.key for provider in list_providers())
|
|
40
|
+
|
|
41
|
+
|
|
42
|
+
def _split_types(skip_types: str | None) -> tuple[str, ...]:
|
|
43
|
+
if not skip_types:
|
|
44
|
+
return ()
|
|
45
|
+
return tuple(part.strip() for part in skip_types.split(",") if part.strip())
|
|
46
|
+
|
|
47
|
+
|
|
48
|
+
def _dotenv(dotenv_path: str | None) -> Path | None:
|
|
49
|
+
return None if dotenv_path is None else Path(dotenv_path)
|
|
50
|
+
|
|
51
|
+
|
|
52
|
+
class Donazopy:
|
|
53
|
+
"""donazopy CLI: DNS and domain-provider management."""
|
|
54
|
+
|
|
55
|
+
def __init__(
|
|
56
|
+
self,
|
|
57
|
+
*,
|
|
58
|
+
dns_factory: DnsFactory = create_dns_provider,
|
|
59
|
+
registrar_factory: RegistrarFactory = create_registrar_provider,
|
|
60
|
+
) -> None:
|
|
61
|
+
self._dns_factory = dns_factory
|
|
62
|
+
self._registrar_factory = registrar_factory
|
|
63
|
+
|
|
64
|
+
# -- internal helpers -------------------------------------------------
|
|
65
|
+
|
|
66
|
+
def _resolve_target(self, text: str) -> tuple[str, Target]:
|
|
67
|
+
target = parse_target(text)
|
|
68
|
+
key = resolve_provider_key(target, _operational_keys())
|
|
69
|
+
return key, target
|
|
70
|
+
|
|
71
|
+
def _dns_provider(self, key: str, dotenv_path: str | None) -> DNSHostingProvider:
|
|
72
|
+
spec = get_provider(key)
|
|
73
|
+
credentials = require_provider_credentials(spec, dotenv_path=_dotenv(dotenv_path))
|
|
74
|
+
return self._dns_factory(key, credentials)
|
|
75
|
+
|
|
76
|
+
def _registrar_provider(self, key: str, dotenv_path: str | None) -> RegistrarProvider:
|
|
77
|
+
spec = get_provider(key)
|
|
78
|
+
credentials = require_provider_credentials(spec, dotenv_path=_dotenv(dotenv_path))
|
|
79
|
+
return self._registrar_factory(key, credentials)
|
|
80
|
+
|
|
81
|
+
@staticmethod
|
|
82
|
+
def _require_domain(target: Target) -> str:
|
|
83
|
+
if target.domain is None or target.domain == "*":
|
|
84
|
+
msg = (
|
|
85
|
+
f"target {target.raw!r} must name a single domain for this operation; "
|
|
86
|
+
"use 'donazopy domains <provider>' to list a provider's domains"
|
|
87
|
+
)
|
|
88
|
+
raise TargetError(msg)
|
|
89
|
+
return target.domain
|
|
90
|
+
|
|
91
|
+
def _provider_key(self, provider: str) -> str:
|
|
92
|
+
"""Resolve a provider key from a bare key (``ionos``) or a target (``ionos/*``)."""
|
|
93
|
+
if provider in _operational_keys():
|
|
94
|
+
return provider
|
|
95
|
+
key, _ = self._resolve_target(provider)
|
|
96
|
+
return key
|
|
97
|
+
|
|
98
|
+
def _provider_info(self, key: str, dotenv_path: str | None) -> dict[str, object]:
|
|
99
|
+
spec = get_provider(key)
|
|
100
|
+
metadata = {
|
|
101
|
+
"key": spec.key,
|
|
102
|
+
"display_name": spec.display_name,
|
|
103
|
+
"category": spec.category,
|
|
104
|
+
"docs_url": spec.docs_url,
|
|
105
|
+
"credentials": list(spec.credentials),
|
|
106
|
+
"capabilities": [capability.name for capability in spec.capabilities],
|
|
107
|
+
"notes": spec.notes,
|
|
108
|
+
}
|
|
109
|
+
status = credential_status(spec, dotenv_path=_dotenv(dotenv_path))
|
|
110
|
+
return {"metadata": metadata, "credential_status": status.to_dict()}
|
|
111
|
+
|
|
112
|
+
def _records_from_side(self, text: str, origin: str | None, dotenv_path: str | None) -> tuple:
|
|
113
|
+
if looks_like_path(text):
|
|
114
|
+
return records_from_zone_file(Path(text), origin)
|
|
115
|
+
key, target = self._resolve_target(text)
|
|
116
|
+
domain = self._require_domain(target)
|
|
117
|
+
zone_text = self._dns_provider(key, dotenv_path).export_zone(domain)
|
|
118
|
+
return records_from_zone_text(zone_text, origin or domain.rstrip(".") + ".")
|
|
119
|
+
|
|
120
|
+
# -- commands ---------------------------------------------------------
|
|
121
|
+
|
|
122
|
+
def version(self) -> str:
|
|
123
|
+
"""Return the installed donazopy version."""
|
|
124
|
+
return __version__
|
|
125
|
+
|
|
126
|
+
def providers(self) -> list[str]:
|
|
127
|
+
"""List the operational provider keys."""
|
|
128
|
+
return list(_operational_keys())
|
|
129
|
+
|
|
130
|
+
def domains(self, provider: str, dotenv_path: str | None = None) -> list[str]:
|
|
131
|
+
"""List the domains/zones managed by a provider.
|
|
132
|
+
|
|
133
|
+
``provider`` is a provider key (e.g. ``ionos``) or a target like ``ionos/*``.
|
|
134
|
+
"""
|
|
135
|
+
key = self._provider_key(provider)
|
|
136
|
+
return self._dns_provider(key, dotenv_path).list_zones()
|
|
137
|
+
|
|
138
|
+
def status(self, target: str | None = None, dotenv_path: str | None = None) -> dict[str, object]:
|
|
139
|
+
"""Show provider metadata and credential status.
|
|
140
|
+
|
|
141
|
+
With no argument, returns one entry per operational provider. With a provider
|
|
142
|
+
key or full target string, returns just that provider's entry.
|
|
143
|
+
"""
|
|
144
|
+
if target is None:
|
|
145
|
+
return {key: self._provider_info(key, dotenv_path) for key in _operational_keys()}
|
|
146
|
+
operational = _operational_keys()
|
|
147
|
+
if target in operational:
|
|
148
|
+
return self._provider_info(target, dotenv_path)
|
|
149
|
+
key, _ = self._resolve_target(target)
|
|
150
|
+
return self._provider_info(key, dotenv_path)
|
|
151
|
+
|
|
152
|
+
def records(self, target: str, dotenv_path: str | None = None) -> list[Mapping[str, object]]:
|
|
153
|
+
"""List DNS records for the domain in ``target``, applying record-level filters."""
|
|
154
|
+
key, parsed = self._resolve_target(target)
|
|
155
|
+
domain = self._require_domain(parsed)
|
|
156
|
+
records = self._dns_provider(key, dotenv_path).list_records(domain)
|
|
157
|
+
return [record for record in records if parsed.matches_record(record)]
|
|
158
|
+
|
|
159
|
+
def export(
|
|
160
|
+
self,
|
|
161
|
+
target: str,
|
|
162
|
+
dotenv_path: str | None = None,
|
|
163
|
+
output: str | None = None,
|
|
164
|
+
overwrite: bool = False,
|
|
165
|
+
skip_ns: bool = False,
|
|
166
|
+
skip_types: str | None = None,
|
|
167
|
+
) -> str:
|
|
168
|
+
"""Export a zone as BIND text, optionally dropping NS records or given types."""
|
|
169
|
+
key, parsed = self._resolve_target(target)
|
|
170
|
+
domain = self._require_domain(parsed)
|
|
171
|
+
zone_text = self._dns_provider(key, dotenv_path).export_zone(domain)
|
|
172
|
+
origin = domain.rstrip(".") + "."
|
|
173
|
+
filtered = filter_zone_text(zone_text, origin, skip_ns=skip_ns, skip_types=_split_types(skip_types))
|
|
174
|
+
if output is not None:
|
|
175
|
+
write_text_safely(Path(output), filtered, overwrite=overwrite)
|
|
176
|
+
return filtered
|
|
177
|
+
|
|
178
|
+
def import_zone(
|
|
179
|
+
self,
|
|
180
|
+
target: str,
|
|
181
|
+
path: str,
|
|
182
|
+
dotenv_path: str | None = None,
|
|
183
|
+
proxied: bool | None = None,
|
|
184
|
+
) -> Mapping[str, object]:
|
|
185
|
+
"""Import BIND zone text from ``path`` into the domain in ``target``."""
|
|
186
|
+
key, parsed = self._resolve_target(target)
|
|
187
|
+
domain = self._require_domain(parsed)
|
|
188
|
+
zone_text = Path(path).read_text(encoding="utf-8")
|
|
189
|
+
return self._dns_provider(key, dotenv_path).import_zone(domain, zone_text, proxied=proxied)
|
|
190
|
+
|
|
191
|
+
def create_zone(self, target: str, dotenv_path: str | None = None) -> Mapping[str, object]:
|
|
192
|
+
"""Create a hosted zone for the domain in ``target`` on its provider.
|
|
193
|
+
|
|
194
|
+
Idempotent where the provider supports it (returns the existing zone). Providers
|
|
195
|
+
that cannot create zones (the zone exists with the domain registration) raise a
|
|
196
|
+
clear "not supported" error.
|
|
197
|
+
"""
|
|
198
|
+
key, parsed = self._resolve_target(target)
|
|
199
|
+
domain = self._require_domain(parsed)
|
|
200
|
+
return self._dns_provider(key, dotenv_path).create_zone(domain)
|
|
201
|
+
|
|
202
|
+
def copy(
|
|
203
|
+
self,
|
|
204
|
+
source: str,
|
|
205
|
+
dest: str,
|
|
206
|
+
dotenv_path: str | None = None,
|
|
207
|
+
skip_ns: bool = False,
|
|
208
|
+
skip_types: str | None = None,
|
|
209
|
+
replace: bool = False,
|
|
210
|
+
create: bool = True,
|
|
211
|
+
) -> Mapping[str, object]:
|
|
212
|
+
"""Copy a zone from ``source`` to ``dest``, optionally replacing existing records.
|
|
213
|
+
|
|
214
|
+
``source`` and ``dest`` are full targets. If the destination domain is ``*`` or
|
|
215
|
+
omitted, it defaults to the source domain. By default the destination zone is
|
|
216
|
+
created first if it does not exist and the provider supports it (useful when
|
|
217
|
+
migrating a domain to a new DNS host); pass ``--create=False`` to skip that. The
|
|
218
|
+
result's ``created`` entry is the created/existing zone object, or ``None`` when
|
|
219
|
+
the destination provider does not support zone creation.
|
|
220
|
+
"""
|
|
221
|
+
source_key, source_target = self._resolve_target(source)
|
|
222
|
+
source_domain = self._require_domain(source_target)
|
|
223
|
+
dest_key, dest_target = self._resolve_target(dest)
|
|
224
|
+
dest_domain = source_domain if dest_target.domain in (None, "*") else dest_target.domain
|
|
225
|
+
|
|
226
|
+
source_zone_text = self._dns_provider(source_key, dotenv_path).export_zone(source_domain)
|
|
227
|
+
origin = source_domain.rstrip(".") + "."
|
|
228
|
+
filtered = filter_zone_text(source_zone_text, origin, skip_ns=skip_ns, skip_types=_split_types(skip_types))
|
|
229
|
+
exported_records = len([line for line in filtered.splitlines() if line.strip()])
|
|
230
|
+
|
|
231
|
+
dest_provider = self._dns_provider(dest_key, dotenv_path)
|
|
232
|
+
created: Mapping[str, object] | None = None
|
|
233
|
+
if create:
|
|
234
|
+
try:
|
|
235
|
+
created = dest_provider.create_zone(dest_domain)
|
|
236
|
+
except ProviderAPIError as error:
|
|
237
|
+
# Some providers create the DNS zone with the domain registration; tolerate that.
|
|
238
|
+
if "not supported" not in str(error).lower():
|
|
239
|
+
raise
|
|
240
|
+
replaced: Mapping[str, object] | None = None
|
|
241
|
+
if replace:
|
|
242
|
+
replaced = dest_provider.delete_all_records(dest_domain)
|
|
243
|
+
import_result = dest_provider.import_zone(dest_domain, filtered)
|
|
244
|
+
return {
|
|
245
|
+
"source": source_target.to_dict(),
|
|
246
|
+
"dest": {**dest_target.to_dict(), "domain": dest_domain},
|
|
247
|
+
"exported_records": exported_records,
|
|
248
|
+
"created": created,
|
|
249
|
+
"replaced": replaced,
|
|
250
|
+
"import_result": import_result,
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
def nameservers(
|
|
254
|
+
self,
|
|
255
|
+
target: str,
|
|
256
|
+
*new_nameservers: str,
|
|
257
|
+
dotenv_path: str | None = None,
|
|
258
|
+
) -> object:
|
|
259
|
+
"""Read nameservers for a domain, or assign them when values are given.
|
|
260
|
+
|
|
261
|
+
``target`` with a wildcard domain (``provider/*``) reads nameservers for every
|
|
262
|
+
domain the provider manages and returns a ``{domain: [nameserver, ...]}`` map.
|
|
263
|
+
Assigning nameservers always requires a single concrete domain.
|
|
264
|
+
"""
|
|
265
|
+
key, parsed = self._resolve_target(target)
|
|
266
|
+
provider = self._registrar_provider(key, dotenv_path)
|
|
267
|
+
if parsed.domain in (None, "*"):
|
|
268
|
+
if new_nameservers:
|
|
269
|
+
self._require_domain(parsed) # raise the standard "single domain" error
|
|
270
|
+
dns_provider = self._dns_provider(key, dotenv_path)
|
|
271
|
+
return {domain: list(provider.read_nameservers(domain)) for domain in dns_provider.list_zones()}
|
|
272
|
+
domain = self._require_domain(parsed)
|
|
273
|
+
if not new_nameservers:
|
|
274
|
+
return list(provider.read_nameservers(domain))
|
|
275
|
+
return provider.assign_nameservers(domain, list(new_nameservers))
|
|
276
|
+
|
|
277
|
+
def diff(
|
|
278
|
+
self,
|
|
279
|
+
a: str,
|
|
280
|
+
b: str,
|
|
281
|
+
origin: str | None = None,
|
|
282
|
+
dotenv_path: str | None = None,
|
|
283
|
+
) -> dict[str, object]:
|
|
284
|
+
"""Diff two zones; each side is a local zone file path or a provider target."""
|
|
285
|
+
before = self._records_from_side(a, origin, dotenv_path)
|
|
286
|
+
after = self._records_from_side(b, origin, dotenv_path)
|
|
287
|
+
zone_diff = diff_zone_records(before, after)
|
|
288
|
+
return {"summary": zone_diff.summary(), "changes": zone_diff.to_dict()}
|
|
289
|
+
|
|
290
|
+
def validate(self, path: str, origin: str | None = None) -> str:
|
|
291
|
+
"""Validate a local BIND zone file."""
|
|
292
|
+
return validate_zone_file(Path(path), origin)
|
|
293
|
+
|
|
294
|
+
def normalize(
|
|
295
|
+
self,
|
|
296
|
+
path: str,
|
|
297
|
+
origin: str | None = None,
|
|
298
|
+
output: str | None = None,
|
|
299
|
+
overwrite: bool = False,
|
|
300
|
+
) -> str:
|
|
301
|
+
"""Return (and optionally write) a canonical normalized dump of a zone file."""
|
|
302
|
+
normalized = normalize_zone_file(Path(path), origin)
|
|
303
|
+
if output is not None:
|
|
304
|
+
write_text_safely(Path(output), normalized, overwrite=overwrite)
|
|
305
|
+
return normalized
|
donazopy/models.py
ADDED
|
@@ -0,0 +1,29 @@
|
|
|
1
|
+
# this_file: src/donazopy/models.py
|
|
2
|
+
"""Shared data models for provider metadata and DNS operation boundaries."""
|
|
3
|
+
|
|
4
|
+
from dataclasses import dataclass
|
|
5
|
+
|
|
6
|
+
|
|
7
|
+
@dataclass(frozen=True, slots=True)
|
|
8
|
+
class ProviderCapability:
|
|
9
|
+
"""A named provider capability exposed by a DNS or registrar integration."""
|
|
10
|
+
|
|
11
|
+
name: str
|
|
12
|
+
description: str
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
@dataclass(frozen=True, slots=True)
|
|
16
|
+
class ProviderSpec:
|
|
17
|
+
"""Static metadata describing a provider integration module."""
|
|
18
|
+
|
|
19
|
+
key: str
|
|
20
|
+
display_name: str
|
|
21
|
+
category: str
|
|
22
|
+
docs_url: str
|
|
23
|
+
credentials: tuple[str, ...]
|
|
24
|
+
capabilities: tuple[ProviderCapability, ...]
|
|
25
|
+
notes: str
|
|
26
|
+
|
|
27
|
+
def supports(self, capability_name: str) -> bool:
|
|
28
|
+
"""Return whether this provider advertises a capability by name."""
|
|
29
|
+
return any(capability.name == capability_name for capability in self.capabilities)
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
# this_file: src/donazopy/providers/aws.py
|
|
2
|
+
from donazopy.providers.base import DNS_AND_REGISTRAR, ProviderSpec
|
|
3
|
+
|
|
4
|
+
PROVIDER = ProviderSpec(
|
|
5
|
+
key="aws",
|
|
6
|
+
display_name="AWS Route 53",
|
|
7
|
+
category="dns_and_registrar",
|
|
8
|
+
docs_url="https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/route53.html",
|
|
9
|
+
credentials=("AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION"),
|
|
10
|
+
capabilities=DNS_AND_REGISTRAR,
|
|
11
|
+
notes="Route 53 separates hosted-zone record changes from domain registration and nameserver operations.",
|
|
12
|
+
)
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
# this_file: src/donazopy/providers/azure.py
|
|
2
|
+
from donazopy.providers.base import DNS_ONLY, ProviderSpec
|
|
3
|
+
|
|
4
|
+
PROVIDER = ProviderSpec(
|
|
5
|
+
key="azure",
|
|
6
|
+
display_name="Azure DNS",
|
|
7
|
+
category="dns_host",
|
|
8
|
+
docs_url="https://learn.microsoft.com/en-us/rest/api/dns/",
|
|
9
|
+
credentials=("AZURE_TENANT_ID", "AZURE_CLIENT_ID", "AZURE_CLIENT_SECRET", "AZURE_SUBSCRIPTION_ID"),
|
|
10
|
+
capabilities=DNS_ONLY,
|
|
11
|
+
notes="Azure DNS manages hosted zones and record sets; registrar delegation is handled elsewhere.",
|
|
12
|
+
)
|
|
@@ -0,0 +1,211 @@
|
|
|
1
|
+
# this_file: src/donazopy/providers/base.py
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
import os
|
|
6
|
+
from collections.abc import Mapping, Sequence
|
|
7
|
+
from dataclasses import dataclass
|
|
8
|
+
from pathlib import Path
|
|
9
|
+
from typing import Protocol, runtime_checkable
|
|
10
|
+
|
|
11
|
+
from dotenv import dotenv_values, find_dotenv
|
|
12
|
+
|
|
13
|
+
from donazopy.models import ProviderCapability, ProviderSpec
|
|
14
|
+
|
|
15
|
+
ZONE_READ = ProviderCapability("zone_read", "Read hosted DNS zones and records.")
|
|
16
|
+
ZONE_WRITE = ProviderCapability("zone_write", "Create, update, delete, or import hosted DNS records.")
|
|
17
|
+
ZONE_EXPORT = ProviderCapability("zone_export", "Export DNS configuration to BIND-compatible zone text.")
|
|
18
|
+
ZONE_IMPORT = ProviderCapability("zone_import", "Import or synchronize DNS configuration from zone text.")
|
|
19
|
+
DELEGATION_READ = ProviderCapability("delegation_read", "Read registrar-level nameserver delegation.")
|
|
20
|
+
DOMAIN_READ = ProviderCapability("domain_read", "List or inspect registered domains.")
|
|
21
|
+
|
|
22
|
+
DNS_ONLY = (ZONE_READ, ZONE_WRITE, ZONE_EXPORT, ZONE_IMPORT)
|
|
23
|
+
DNS_AND_REGISTRAR_READ = DNS_ONLY + (DOMAIN_READ, DELEGATION_READ)
|
|
24
|
+
DNS_AND_REGISTRAR = DNS_AND_REGISTRAR_READ
|
|
25
|
+
|
|
26
|
+
|
|
27
|
+
class ProviderError(RuntimeError):
|
|
28
|
+
pass
|
|
29
|
+
|
|
30
|
+
|
|
31
|
+
class ProviderCredentialError(ProviderError):
|
|
32
|
+
pass
|
|
33
|
+
|
|
34
|
+
|
|
35
|
+
class ProviderAPIError(ProviderError):
|
|
36
|
+
pass
|
|
37
|
+
|
|
38
|
+
|
|
39
|
+
@dataclass(frozen=True, slots=True)
|
|
40
|
+
class CredentialStatus:
|
|
41
|
+
provider_key: str
|
|
42
|
+
required: tuple[str, ...]
|
|
43
|
+
present: tuple[str, ...]
|
|
44
|
+
missing: tuple[str, ...]
|
|
45
|
+
sources: Mapping[str, str]
|
|
46
|
+
|
|
47
|
+
@property
|
|
48
|
+
def is_complete(self) -> bool:
|
|
49
|
+
return not self.missing
|
|
50
|
+
|
|
51
|
+
def to_dict(self) -> dict[str, object]:
|
|
52
|
+
return {
|
|
53
|
+
"provider_key": self.provider_key,
|
|
54
|
+
"required": list(self.required),
|
|
55
|
+
"present": list(self.present),
|
|
56
|
+
"missing": list(self.missing),
|
|
57
|
+
"complete": self.is_complete,
|
|
58
|
+
"sources": dict(self.sources),
|
|
59
|
+
"redacted": dict.fromkeys(self.present, "***"),
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
|
|
63
|
+
@dataclass(frozen=True, slots=True)
|
|
64
|
+
class LoadedCredentials:
|
|
65
|
+
values: Mapping[str, str]
|
|
66
|
+
sources: Mapping[str, str]
|
|
67
|
+
|
|
68
|
+
|
|
69
|
+
@runtime_checkable
|
|
70
|
+
class DNSHostingProvider(Protocol):
|
|
71
|
+
spec: ProviderSpec
|
|
72
|
+
|
|
73
|
+
def export_zone(self, domain: str) -> str: ...
|
|
74
|
+
|
|
75
|
+
def import_zone(self, domain: str, zone_text: str, *, proxied: bool | None = None) -> Mapping[str, object]: ...
|
|
76
|
+
|
|
77
|
+
def list_records(self, domain: str) -> list[Mapping[str, object]]: ...
|
|
78
|
+
|
|
79
|
+
def delete_all_records(self, domain: str) -> Mapping[str, object]:
|
|
80
|
+
"""Delete every deletable record in a zone.
|
|
81
|
+
|
|
82
|
+
Implementations that cannot do this should raise :class:`ProviderAPIError`.
|
|
83
|
+
"""
|
|
84
|
+
...
|
|
85
|
+
|
|
86
|
+
def list_zones(self) -> list[str]:
|
|
87
|
+
"""Return all zone names hosted by the provider.
|
|
88
|
+
|
|
89
|
+
Implementations that cannot enumerate zones should raise :class:`ProviderAPIError`.
|
|
90
|
+
"""
|
|
91
|
+
...
|
|
92
|
+
|
|
93
|
+
def create_zone(self, domain: str) -> Mapping[str, object]:
|
|
94
|
+
"""Create a hosted zone for ``domain`` and return the provider's zone object.
|
|
95
|
+
|
|
96
|
+
Implementations should be idempotent (returning the existing zone if it already
|
|
97
|
+
exists) and should raise :class:`ProviderAPIError` if they cannot create zones.
|
|
98
|
+
"""
|
|
99
|
+
...
|
|
100
|
+
|
|
101
|
+
|
|
102
|
+
@runtime_checkable
|
|
103
|
+
class RegistrarProvider(Protocol):
|
|
104
|
+
spec: ProviderSpec
|
|
105
|
+
|
|
106
|
+
def read_nameservers(self, domain: str) -> tuple[str, ...]: ...
|
|
107
|
+
|
|
108
|
+
def assign_nameservers(self, domain: str, nameservers: Sequence[str]) -> Mapping[str, object]:
|
|
109
|
+
"""Set registrar nameserver delegation for a domain.
|
|
110
|
+
|
|
111
|
+
Implementations that cannot do this should raise :class:`ProviderAPIError`.
|
|
112
|
+
"""
|
|
113
|
+
...
|
|
114
|
+
|
|
115
|
+
|
|
116
|
+
def dotenv_environment(
|
|
117
|
+
*,
|
|
118
|
+
dotenv_path: Path | None = None,
|
|
119
|
+
env: Mapping[str, str] | None = None,
|
|
120
|
+
discover: bool = True,
|
|
121
|
+
) -> LoadedCredentials:
|
|
122
|
+
merged: dict[str, str] = {}
|
|
123
|
+
sources: dict[str, str] = {}
|
|
124
|
+
|
|
125
|
+
discovered = find_dotenv(usecwd=True) if discover else ""
|
|
126
|
+
dotenv_files = [Path(discovered)] if discovered else []
|
|
127
|
+
if dotenv_path is not None:
|
|
128
|
+
dotenv_files.append(dotenv_path)
|
|
129
|
+
|
|
130
|
+
for path in dotenv_files:
|
|
131
|
+
if path.exists():
|
|
132
|
+
for key, value in dotenv_values(path).items():
|
|
133
|
+
if value:
|
|
134
|
+
merged[key] = value
|
|
135
|
+
sources[key] = str(path)
|
|
136
|
+
|
|
137
|
+
environment = os.environ if env is None else env
|
|
138
|
+
for key, value in environment.items():
|
|
139
|
+
if value:
|
|
140
|
+
merged[key] = value
|
|
141
|
+
sources[key] = "environment"
|
|
142
|
+
|
|
143
|
+
return LoadedCredentials(values=merged, sources=sources)
|
|
144
|
+
|
|
145
|
+
|
|
146
|
+
def load_provider_credentials(
|
|
147
|
+
spec: ProviderSpec,
|
|
148
|
+
*,
|
|
149
|
+
dotenv_path: Path | None = None,
|
|
150
|
+
env: Mapping[str, str] | None = None,
|
|
151
|
+
discover: bool = True,
|
|
152
|
+
) -> dict[str, str]:
|
|
153
|
+
loaded = dotenv_environment(dotenv_path=dotenv_path, env=env, discover=discover)
|
|
154
|
+
return {name: loaded.values[name] for name in spec.credentials if loaded.values.get(name)}
|
|
155
|
+
|
|
156
|
+
|
|
157
|
+
def credential_status(
|
|
158
|
+
spec: ProviderSpec,
|
|
159
|
+
*,
|
|
160
|
+
dotenv_path: Path | None = None,
|
|
161
|
+
env: Mapping[str, str] | None = None,
|
|
162
|
+
discover: bool = True,
|
|
163
|
+
) -> CredentialStatus:
|
|
164
|
+
loaded = dotenv_environment(dotenv_path=dotenv_path, env=env, discover=discover)
|
|
165
|
+
credentials = {name: loaded.values[name] for name in spec.credentials if loaded.values.get(name)}
|
|
166
|
+
present = tuple(name for name in spec.credentials if name in credentials)
|
|
167
|
+
missing = tuple(name for name in spec.credentials if name not in credentials)
|
|
168
|
+
sources = {name: loaded.sources[name] for name in present if name in loaded.sources}
|
|
169
|
+
return CredentialStatus(
|
|
170
|
+
provider_key=spec.key, required=spec.credentials, present=present, missing=missing, sources=sources
|
|
171
|
+
)
|
|
172
|
+
|
|
173
|
+
|
|
174
|
+
def require_provider_credentials(
|
|
175
|
+
spec: ProviderSpec,
|
|
176
|
+
*,
|
|
177
|
+
dotenv_path: Path | None = None,
|
|
178
|
+
env: Mapping[str, str] | None = None,
|
|
179
|
+
discover: bool = True,
|
|
180
|
+
) -> dict[str, str]:
|
|
181
|
+
status = credential_status(spec, dotenv_path=dotenv_path, env=env, discover=discover)
|
|
182
|
+
if not status.is_complete:
|
|
183
|
+
missing = ", ".join(status.missing)
|
|
184
|
+
raise ProviderCredentialError(f"missing required credentials for {spec.key}: {missing}")
|
|
185
|
+
return load_provider_credentials(spec, dotenv_path=dotenv_path, env=env, discover=discover)
|
|
186
|
+
|
|
187
|
+
|
|
188
|
+
__all__ = [
|
|
189
|
+
"CredentialStatus",
|
|
190
|
+
"DELEGATION_READ",
|
|
191
|
+
"DNSHostingProvider",
|
|
192
|
+
"DNS_AND_REGISTRAR",
|
|
193
|
+
"DNS_AND_REGISTRAR_READ",
|
|
194
|
+
"DNS_ONLY",
|
|
195
|
+
"DOMAIN_READ",
|
|
196
|
+
"LoadedCredentials",
|
|
197
|
+
"ProviderAPIError",
|
|
198
|
+
"ProviderCapability",
|
|
199
|
+
"ProviderCredentialError",
|
|
200
|
+
"ProviderError",
|
|
201
|
+
"ProviderSpec",
|
|
202
|
+
"RegistrarProvider",
|
|
203
|
+
"ZONE_EXPORT",
|
|
204
|
+
"ZONE_IMPORT",
|
|
205
|
+
"ZONE_READ",
|
|
206
|
+
"ZONE_WRITE",
|
|
207
|
+
"credential_status",
|
|
208
|
+
"dotenv_environment",
|
|
209
|
+
"load_provider_credentials",
|
|
210
|
+
"require_provider_credentials",
|
|
211
|
+
]
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
# this_file: src/donazopy/providers/bluehost.py
|
|
2
|
+
from donazopy.providers.base import DNS_AND_REGISTRAR, ProviderSpec
|
|
3
|
+
|
|
4
|
+
PROVIDER = ProviderSpec(
|
|
5
|
+
key="bluehost",
|
|
6
|
+
display_name="Bluehost",
|
|
7
|
+
category="dns_and_registrar",
|
|
8
|
+
docs_url="https://www.bluehost.com/",
|
|
9
|
+
credentials=("BLUEHOST_API_TOKEN",),
|
|
10
|
+
capabilities=DNS_AND_REGISTRAR,
|
|
11
|
+
notes="Bluehost automation may require account-specific APIs or registrar workflows; verify before enabling writes.",
|
|
12
|
+
)
|