|
|
"""
|
|
|
Cloudflare API Client
|
|
|
Handles authentication and base HTTP operations for Cloudflare services
|
|
|
"""
|
|
|
|
|
|
import asyncio
|
|
|
import json
|
|
|
from typing import Any, Dict, Optional, Union
|
|
|
|
|
|
import aiohttp
|
|
|
|
|
|
from app.logger import logger
|
|
|
|
|
|
|
|
|
class CloudflareClient:
|
|
|
"""Base client for Cloudflare API operations"""
|
|
|
|
|
|
def __init__(
|
|
|
self,
|
|
|
api_token: str,
|
|
|
account_id: str,
|
|
|
worker_url: Optional[str] = None,
|
|
|
timeout: int = 30,
|
|
|
):
|
|
|
self.api_token = api_token
|
|
|
self.account_id = account_id
|
|
|
self.worker_url = worker_url
|
|
|
self.timeout = timeout
|
|
|
self.base_url = "https://api.cloudflare.com/client/v4"
|
|
|
|
|
|
|
|
|
self.headers = {
|
|
|
"Authorization": f"Bearer {api_token}",
|
|
|
"Content-Type": "application/json",
|
|
|
}
|
|
|
|
|
|
async def _make_request(
|
|
|
self,
|
|
|
method: str,
|
|
|
url: str,
|
|
|
data: Optional[Dict[str, Any]] = None,
|
|
|
headers: Optional[Dict[str, str]] = None,
|
|
|
use_worker: bool = False,
|
|
|
) -> Dict[str, Any]:
|
|
|
"""Make HTTP request to Cloudflare API or Worker"""
|
|
|
|
|
|
|
|
|
if use_worker and self.worker_url:
|
|
|
full_url = f"{self.worker_url.rstrip('/')}/{url.lstrip('/')}"
|
|
|
else:
|
|
|
full_url = f"{self.base_url}/{url.lstrip('/')}"
|
|
|
|
|
|
request_headers = self.headers.copy()
|
|
|
if headers:
|
|
|
request_headers.update(headers)
|
|
|
|
|
|
timeout = aiohttp.ClientTimeout(total=self.timeout)
|
|
|
|
|
|
try:
|
|
|
async with aiohttp.ClientSession(timeout=timeout) as session:
|
|
|
async with session.request(
|
|
|
method=method.upper(),
|
|
|
url=full_url,
|
|
|
headers=request_headers,
|
|
|
json=data if data else None,
|
|
|
) as response:
|
|
|
response_text = await response.text()
|
|
|
|
|
|
try:
|
|
|
response_data = (
|
|
|
json.loads(response_text) if response_text else {}
|
|
|
)
|
|
|
except json.JSONDecodeError:
|
|
|
response_data = {"raw_response": response_text}
|
|
|
|
|
|
if not response.ok:
|
|
|
logger.error(
|
|
|
f"Cloudflare API error: {response.status} - {response_text}"
|
|
|
)
|
|
|
raise CloudflareError(
|
|
|
f"HTTP {response.status}: {response_text}",
|
|
|
response.status,
|
|
|
response_data,
|
|
|
)
|
|
|
|
|
|
return response_data
|
|
|
|
|
|
except asyncio.TimeoutError:
|
|
|
logger.error(f"Timeout making request to {full_url}")
|
|
|
raise CloudflareError(f"Request timeout after {self.timeout}s")
|
|
|
except aiohttp.ClientError as e:
|
|
|
logger.error(f"HTTP client error: {e}")
|
|
|
raise CloudflareError(f"Client error: {e}")
|
|
|
|
|
|
async def get(
|
|
|
self,
|
|
|
url: str,
|
|
|
headers: Optional[Dict[str, str]] = None,
|
|
|
use_worker: bool = False,
|
|
|
) -> Dict[str, Any]:
|
|
|
"""Make GET request"""
|
|
|
return await self._make_request(
|
|
|
"GET", url, headers=headers, use_worker=use_worker
|
|
|
)
|
|
|
|
|
|
async def post(
|
|
|
self,
|
|
|
url: str,
|
|
|
data: Optional[Dict[str, Any]] = None,
|
|
|
headers: Optional[Dict[str, str]] = None,
|
|
|
use_worker: bool = False,
|
|
|
) -> Dict[str, Any]:
|
|
|
"""Make POST request"""
|
|
|
return await self._make_request(
|
|
|
"POST", url, data=data, headers=headers, use_worker=use_worker
|
|
|
)
|
|
|
|
|
|
async def put(
|
|
|
self,
|
|
|
url: str,
|
|
|
data: Optional[Dict[str, Any]] = None,
|
|
|
headers: Optional[Dict[str, str]] = None,
|
|
|
use_worker: bool = False,
|
|
|
) -> Dict[str, Any]:
|
|
|
"""Make PUT request"""
|
|
|
return await self._make_request(
|
|
|
"PUT", url, data=data, headers=headers, use_worker=use_worker
|
|
|
)
|
|
|
|
|
|
async def delete(
|
|
|
self,
|
|
|
url: str,
|
|
|
headers: Optional[Dict[str, str]] = None,
|
|
|
use_worker: bool = False,
|
|
|
) -> Dict[str, Any]:
|
|
|
"""Make DELETE request"""
|
|
|
return await self._make_request(
|
|
|
"DELETE", url, headers=headers, use_worker=use_worker
|
|
|
)
|
|
|
|
|
|
async def upload_file(
|
|
|
self,
|
|
|
url: str,
|
|
|
file_data: bytes,
|
|
|
content_type: str = "application/octet-stream",
|
|
|
headers: Optional[Dict[str, str]] = None,
|
|
|
use_worker: bool = False,
|
|
|
) -> Dict[str, Any]:
|
|
|
"""Upload file data"""
|
|
|
|
|
|
|
|
|
if use_worker and self.worker_url:
|
|
|
full_url = f"{self.worker_url.rstrip('/')}/{url.lstrip('/')}"
|
|
|
else:
|
|
|
full_url = f"{self.base_url}/{url.lstrip('/')}"
|
|
|
|
|
|
upload_headers = {
|
|
|
"Authorization": f"Bearer {self.api_token}",
|
|
|
"Content-Type": content_type,
|
|
|
}
|
|
|
if headers:
|
|
|
upload_headers.update(headers)
|
|
|
|
|
|
timeout = aiohttp.ClientTimeout(
|
|
|
total=self.timeout * 2
|
|
|
)
|
|
|
|
|
|
try:
|
|
|
async with aiohttp.ClientSession(timeout=timeout) as session:
|
|
|
async with session.put(
|
|
|
url=full_url, headers=upload_headers, data=file_data
|
|
|
) as response:
|
|
|
response_text = await response.text()
|
|
|
|
|
|
try:
|
|
|
response_data = (
|
|
|
json.loads(response_text) if response_text else {}
|
|
|
)
|
|
|
except json.JSONDecodeError:
|
|
|
response_data = {"raw_response": response_text}
|
|
|
|
|
|
if not response.ok:
|
|
|
logger.error(
|
|
|
f"File upload error: {response.status} - {response_text}"
|
|
|
)
|
|
|
raise CloudflareError(
|
|
|
f"Upload failed: HTTP {response.status}",
|
|
|
response.status,
|
|
|
response_data,
|
|
|
)
|
|
|
|
|
|
return response_data
|
|
|
|
|
|
except asyncio.TimeoutError:
|
|
|
logger.error(f"Timeout uploading file to {full_url}")
|
|
|
raise CloudflareError(f"Upload timeout after {self.timeout * 2}s")
|
|
|
except aiohttp.ClientError as e:
|
|
|
logger.error(f"Upload client error: {e}")
|
|
|
raise CloudflareError(f"Upload error: {e}")
|
|
|
|
|
|
def get_account_url(self, endpoint: str) -> str:
|
|
|
"""Get URL for account-scoped endpoint"""
|
|
|
return f"accounts/{self.account_id}/{endpoint}"
|
|
|
|
|
|
def get_worker_url(self, endpoint: str) -> str:
|
|
|
"""Get URL for worker endpoint"""
|
|
|
if not self.worker_url:
|
|
|
raise CloudflareError("Worker URL not configured")
|
|
|
return endpoint
|
|
|
|
|
|
|
|
|
class CloudflareError(Exception):
|
|
|
"""Cloudflare API error"""
|
|
|
|
|
|
def __init__(
|
|
|
self,
|
|
|
message: str,
|
|
|
status_code: Optional[int] = None,
|
|
|
response_data: Optional[Dict[str, Any]] = None,
|
|
|
):
|
|
|
super().__init__(message)
|
|
|
self.status_code = status_code
|
|
|
self.response_data = response_data or {}
|
|
|
|
|
|
def __str__(self) -> str:
|
|
|
if self.status_code:
|
|
|
return f"CloudflareError({self.status_code}): {super().__str__()}"
|
|
|
return f"CloudflareError: {super().__str__()}"
|
|
|
|
