174 lines
5.1 KiB
Python
174 lines
5.1 KiB
Python
# Import the urllib.parse, enum and dataclasses modules
|
|
import dataclasses
|
|
import urllib.parse
|
|
import urllib.request
|
|
from dataclasses import dataclass
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
from .errors import ClanError
|
|
|
|
|
|
@dataclass
|
|
class FlakeId:
|
|
_value: str | Path
|
|
|
|
def __str__(self) -> str:
|
|
return f"{self._value}" # The __str__ method returns a custom string representation
|
|
|
|
@property
|
|
def path(self) -> Path:
|
|
assert isinstance(self._value, Path)
|
|
return self._value
|
|
|
|
@property
|
|
def url(self) -> str:
|
|
assert isinstance(self._value, str)
|
|
return self._value
|
|
|
|
def __repr__(self) -> str:
|
|
return f"ClanUrl({self._value})"
|
|
|
|
def is_local(self) -> bool:
|
|
return isinstance(self._value, Path)
|
|
|
|
def is_remote(self) -> bool:
|
|
return isinstance(self._value, str)
|
|
|
|
|
|
# Parameters defined here will be DELETED from the nested uri
|
|
# so make sure there are no conflicts with other webservices
|
|
@dataclass
|
|
class MachineParams:
|
|
dummy_opt: str = "dummy"
|
|
|
|
|
|
@dataclass
|
|
class MachineData:
|
|
flake_id: FlakeId
|
|
name: str = "defaultVM"
|
|
params: MachineParams = dataclasses.field(default_factory=MachineParams)
|
|
|
|
def get_id(self) -> str:
|
|
return f"{self.flake_id}#{self.name}"
|
|
|
|
|
|
# Define the ClanURI class
|
|
class ClanURI:
|
|
_orig_uri: str
|
|
_components: urllib.parse.ParseResult
|
|
flake_id: FlakeId
|
|
_machines: list[MachineData]
|
|
|
|
# Initialize the class with a clan:// URI
|
|
def __init__(self, uri: str) -> None:
|
|
self._machines = []
|
|
|
|
# users might copy whitespace along with the uri
|
|
uri = uri.strip()
|
|
self._orig_uri = uri
|
|
|
|
# Check if the URI starts with clan://
|
|
# If it does, remove the clan:// prefix
|
|
if uri.startswith("clan://"):
|
|
nested_uri = uri[7:]
|
|
else:
|
|
raise ClanError(f"Invalid uri: expected clan://, got {uri}")
|
|
|
|
# Parse the URI into components
|
|
# url://netloc/path;parameters?query#fragment
|
|
self._components = urllib.parse.urlparse(nested_uri)
|
|
|
|
# Replace the query string in the components with the new query string
|
|
clean_comps = self._components._replace(
|
|
query=self._components.query, fragment=""
|
|
)
|
|
|
|
# Parse the URL into a ClanUrl object
|
|
self.flake_id = self._parse_url(clean_comps)
|
|
|
|
# Parse the fragment into a list of machine queries
|
|
# Then parse every machine query into a MachineParameters object
|
|
machine_frags = list(
|
|
filter(lambda x: len(x) > 0, self._components.fragment.split("#"))
|
|
)
|
|
for machine_frag in machine_frags:
|
|
machine = self._parse_machine_query(machine_frag)
|
|
self._machines.append(machine)
|
|
|
|
# If there are no machine fragments, add a default machine
|
|
if len(machine_frags) == 0:
|
|
default_machine = MachineData(flake_id=self.flake_id)
|
|
self._machines.append(default_machine)
|
|
|
|
def _parse_url(self, comps: urllib.parse.ParseResult) -> FlakeId:
|
|
comb = (
|
|
comps.scheme,
|
|
comps.netloc,
|
|
comps.path,
|
|
comps.params,
|
|
comps.query,
|
|
comps.fragment,
|
|
)
|
|
match comb:
|
|
case ("file", "", path, "", "", _) | ("", "", path, "", "", _): # type: ignore
|
|
flake_id = FlakeId(Path(path).expanduser().resolve())
|
|
case _:
|
|
flake_id = FlakeId(comps.geturl())
|
|
|
|
return flake_id
|
|
|
|
def _parse_machine_query(self, machine_frag: str) -> MachineData:
|
|
comp = urllib.parse.urlparse(machine_frag)
|
|
query = urllib.parse.parse_qs(comp.query)
|
|
machine_name = comp.path
|
|
|
|
machine_params: dict[str, Any] = {}
|
|
for dfield in dataclasses.fields(MachineParams):
|
|
if dfield.name in query:
|
|
values = query[dfield.name]
|
|
if len(values) > 1:
|
|
raise ClanError(f"Multiple values for parameter: {dfield.name}")
|
|
machine_params[dfield.name] = values[0]
|
|
|
|
# Remove the field from the query dictionary
|
|
# clan uri and nested uri share one namespace for query parameters
|
|
# we need to make sure there are no conflicts
|
|
del query[dfield.name]
|
|
params = MachineParams(**machine_params)
|
|
machine = MachineData(flake_id=self.flake_id, name=machine_name, params=params)
|
|
return machine
|
|
|
|
@property
|
|
def machine(self) -> MachineData:
|
|
return self._machines[0]
|
|
|
|
def get_orig_uri(self) -> str:
|
|
return self._orig_uri
|
|
|
|
def get_url(self) -> str:
|
|
return str(self.flake_id)
|
|
|
|
@classmethod
|
|
def from_str(
|
|
cls, # noqa
|
|
url: str,
|
|
machine_name: str | None = None,
|
|
) -> "ClanURI":
|
|
clan_uri = ""
|
|
if not url.startswith("clan://"):
|
|
clan_uri += "clan://"
|
|
|
|
clan_uri += url
|
|
|
|
if machine_name:
|
|
clan_uri += f"#{machine_name}"
|
|
|
|
return cls(clan_uri)
|
|
|
|
def __str__(self) -> str:
|
|
return self.get_orig_uri()
|
|
|
|
def __repr__(self) -> str:
|
|
return f"ClanURI({self})"
|