argus-alm 0.12.10__py3-none-any.whl → 0.13.0__py3-none-any.whl

argus/db/cloud_types.py

@@ -1,125 +0,0 @@
-import ipaddress
-import time
-from enum import Enum
-from typing import Optional
-from pydantic.dataclasses import dataclass
-from pydantic import ValidationError, validator
-from argus.db.db_types import ArgusUDTBase
-
-
-@dataclass(init=True, repr=True)
-class CloudInstanceDetails(ArgusUDTBase):
-    provider: str = ""
-    region: str = ""
-    public_ip: str = ""
-    private_ip: str = ""
-    creation_time: int = 0
-    termination_time: int = 0
-    termination_reason: str = ""
-    shards_amount: Optional[int] = 0
-    _typename = "CloudInstanceDetails_v3"
-
-    @classmethod
-    def from_db_udt(cls, udt):
-        return cls(provider=udt.provider, region=udt.region, public_ip=udt.public_ip, private_ip=udt.private_ip,
-                   creation_time=udt.creation_time, termination_time=udt.termination_time,
-                   termination_reason=udt.termination_reason, shards_amount=udt.shards_amount)
-
-    @validator("public_ip")
-    def valid_public_ip_address(cls, v):
-        try:
-            ipaddress.ip_address(v)
-        except ValueError:
-            raise ValidationError(f"Not a valid IPv4(v6) address: {v}")
-
-        return v
-
-    @validator("private_ip")
-    def valid_private_ip_address(cls, v):
-        try:
-            ipaddress.ip_address(v)
-        except ValueError:
-            raise ValidationError(f"Not a valid IPv4(v6) address: {v}")
-
-        return v
-
-
-@dataclass(init=True, repr=True)
-class CloudNodesInfo(ArgusUDTBase):
-    image_id: str
-    instance_type: str
-    node_amount: int
-    post_behaviour: str
-
-    @classmethod
-    def from_db_udt(cls, udt):
-        return cls(image_id=udt.image_id, instance_type=udt.instance_type,
-                   node_amount=udt.node_amount, post_behaviour=udt.post_behaviour)
-
-
-@dataclass(init=True, repr=True)
-class BaseCloudSetupDetails(ArgusUDTBase):
-    db_node: CloudNodesInfo
-    loader_node: CloudNodesInfo
-    monitor_node: CloudNodesInfo
-    backend: str = None
-    _typename = "CloudSetupDetails"
-
-    @classmethod
-    def from_db_udt(cls, udt):
-        db_node = CloudNodesInfo(*udt.db_node)
-        loader_node = CloudNodesInfo(*udt.loader_node)
-        monitor_node = CloudNodesInfo(*udt.monitor_node)
-        backend = udt.backend
-        return cls(db_node=db_node, loader_node=loader_node, monitor_node=monitor_node, backend=backend)
-
-
-@dataclass(init=True, repr=True)
-class AWSSetupDetails(BaseCloudSetupDetails):
-    backend: str = "aws"
-
-
-@dataclass(init=True, repr=True)
-class GCESetupDetails(BaseCloudSetupDetails):
-    backend: str = "gce"
-
-
-class ResourceState(str, Enum):
-    RUNNING = "running"
-    STOPPED = "stopped"
-    TERMINATED = "terminated"
-
-
-@dataclass(init=True, repr=True)
-class CloudResource(ArgusUDTBase):
-    name: str
-    state: ResourceState
-    resource_type: str
-    instance_info: CloudInstanceDetails
-    _typename = "CloudResource_v3"
-
-    def __eq__(self, other) -> bool:
-        if (isinstance(other, CloudResource)):
-            return self.name == other.name
-        return False
-
-    @classmethod
-    def from_db_udt(cls, udt):
-        instance_info = CloudInstanceDetails.from_db_udt(udt.instance_info)
-        return cls(name=udt.name, state=udt.state, resource_type=udt.resource_type, instance_info=instance_info)
-
-    @validator("state")
-    def valid_state(cls, v):
-        try:
-            ResourceState(v)
-        except ValueError:
-            raise ValidationError(f"Not a valid resource state: {v}")
-        return v
-
-    def terminate(self, reason):
-        self.state = ResourceState.TERMINATED
-        self.instance_info.termination_time = int(time.time())
-        self.instance_info.termination_reason = reason
-
-    def stop(self):
-        self.state = ResourceState.STOPPED

argus/db/config.py

@@ -1,135 +0,0 @@
-from abc import ABC
-from typing import Hashable, Any
-from pathlib import Path
-from os import getenv
-import logging
-import yaml
-
-LOGGER = logging.getLogger(__name__)
-
-
-class ConfigLocationError(Exception):
-    pass
-
-
-class BaseConfig(ABC):
-    def __init__(self):
-        pass
-
-    @property
-    def as_dict(self) -> dict[Hashable, Any]:
-        raise NotImplementedError()
-
-    @property
-    def username(self) -> str:
-        raise NotImplementedError()
-
-    @property
-    def password(self) -> str:
-        raise NotImplementedError()
-
-    @property
-    def contact_points(self) -> list[str]:
-        raise NotImplementedError()
-
-    @property
-    def keyspace_name(self) -> str:
-        raise NotImplementedError()
-
-    @property
-    def address_mapping(self) -> dict:
-        return NotImplementedError()
-
-
-class FileConfig(BaseConfig):
-    @property
-    def username(self):
-        return self.as_dict.get("username")
-
-    @property
-    def password(self) -> str:
-        return self.as_dict.get("password")
-
-    @property
-    def contact_points(self) -> list[str]:
-        return self.as_dict.get("contact_points")
-
-    @property
-    def keyspace_name(self) -> str:
-        return self.as_dict.get("keyspace_name")
-
-    @property
-    def address_mapping(self) -> dict:
-        return self.as_dict.get("address_mapping")
-
-    DEFAULT_CONFIG_PATHS = (
-        "./config/argus.local.yaml",
-        "argus.local.yaml",
-        "argus.yaml",
-        getenv("HOME") + "/.argus.yaml"
-    )
-
-    def __init__(self, filepath: str = None):
-        super().__init__()
-        if not filepath:
-            for file in self.DEFAULT_CONFIG_PATHS:
-                LOGGER.info("Trying %s", file)
-                if Path(file).exists():
-                    filepath = file
-                    break
-
-        if not filepath:
-            LOGGER.error("All config locations were tried and no config file found")
-            raise ConfigLocationError("No config file supplied and no config exists at default location")
-
-        self.filepath = filepath
-        self._credentials = None
-
-    @property
-    def as_dict(self) -> dict[Hashable, Any]:
-        if self._credentials:
-            return self._credentials
-        path = Path(self.filepath)
-        if not path.exists():
-            raise ConfigLocationError(f"File not found: {self.filepath}")
-
-        with open(path.absolute(), "rt", encoding="utf-8") as file:
-            self._credentials = yaml.safe_load(file)
-
-        return self._credentials
-
-
-class Config(BaseConfig):
-    @property
-    def username(self) -> str:
-        return self.as_dict.get("username")
-
-    @property
-    def password(self) -> str:
-        return self.as_dict.get("password")
-
-    @property
-    def contact_points(self) -> list[str]:
-        return self.as_dict.get("contact_points")
-
-    @property
-    def keyspace_name(self) -> str:
-        return self.as_dict.get("keyspace_name")
-
-    @property
-    def address_mapping(self) -> dict:
-        return self.as_dict.get("address_mapping")
-
-    def __init__(self, username: str, password: str, contact_points: list[str], keyspace_name: str, address_mapping: dict | None = None):
-        super().__init__()
-        self._config = {
-            "username": username,
-            "password": password,
-            "contact_points": contact_points,
-            "keyspace_name": keyspace_name,
-            "address_mapping": address_mapping,
-        }
-
-    @property
-    def as_dict(self) -> dict[Hashable, Any]:
-        return self._config

argus/db/db_types.py

@@ -1,139 +0,0 @@
-import re
-import time
-from enum import Enum
-from typing import Any, Union, Type, TypeVar, Optional
-from pydantic.dataclasses import dataclass
-from pydantic import validator, ValidationError
-
-
-class ArgusUDTBase:
-    _typename = None
-
-    @classmethod
-    def basename(cls):
-        return cls._typename if cls._typename else cls.__name__
-
-
-@dataclass(init=True, repr=True)
-class NodeDescription(ArgusUDTBase):
-    name: str
-    ip: str
-    shards: int
-
-    @classmethod
-    def from_db_udt(cls, udt):
-        return cls(name=udt.name, ip=udt.ip, shards=udt.shards)
-
-    @validator("ip")
-    def valid_ip_address(cls, value):
-        ip_addr_re = r"(\d{1,3}\.){3}\d{1,3}"
-        if not re.match(ip_addr_re, value):
-            raise ValidationError(f"Not a valid ip address: {value}")
-
-        ip_by_octets = [int(octet) for octet in value.split(".") if int(octet) <= 255]
-        if len(ip_by_octets) != 4:
-            raise ValidationError(f"Octets out of range (0, 255): {value}")
-
-        return value
-
-
-@dataclass(init=True, repr=True)
-class PackageVersion(ArgusUDTBase):
-    name: str
-    version: str
-    date: str
-    revision_id: str
-    build_id: Optional[str] = ""
-    _typename = "PackageVersion_v2"
-
-    @classmethod
-    def from_db_udt(cls, udt):
-        return cls(name=udt.name, version=udt.version,
-                   date=udt.date, revision_id=udt.revision_id, build_id=udt.build_id)
-
-
-class NemesisStatus(str, Enum):
-    STARTED = "started"
-    RUNNING = "running"
-    FAILED = "failed"
-    SKIPPED = "skipped"
-    SUCCEEDED = "succeeded"
-    TERMINATED = "terminated"
-
-
-class TestStatus(str, Enum):
-    CREATED = "created"
-    RUNNING = "running"
-    FAILED = "failed"
-    PASSED = "passed"
-    ABORTED = "aborted"
-    NOT_PLANNED = "not_planned"
-    NOT_RUN = "not_run"
-
-
-class TestInvestigationStatus(str, Enum):
-    NOT_INVESTIGATED = "not_investigated"
-    IN_PROGRESS = "in_progress"
-    INVESTIGATED = "investigated"
-
-
-@dataclass(init=True, repr=True)
-class NemesisRunInfo(ArgusUDTBase):
-    class_name: str
-    name: str
-    duration: int
-    target_node: NodeDescription
-    status: str
-    start_time: int
-    end_time: int = 0
-    stack_trace: str = ""
-
-    @property
-    def nemesis_status(self):
-        return NemesisStatus(self.status)
-
-    @nemesis_status.setter
-    def nemesis_status(self, value: NemesisStatus):
-        self.status = NemesisStatus(value).value
-
-    @classmethod
-    def from_db_udt(cls, udt):
-        target_node = NodeDescription.from_db_udt(udt.target_node)
-        return cls(class_name=udt.class_name, name=udt.name, duration=udt.duration,
-                   target_node=target_node, status=udt.status, start_time=udt.start_time, end_time=udt.end_time,
-                   stack_trace=udt.stack_trace)
-
-    def complete(self, stack_trace=None):
-        self.end_time = int(time.time())
-        if stack_trace:
-            self.nemesis_status = NemesisStatus.FAILED
-            self.stack_trace = stack_trace
-        else:
-            self.nemesis_status = NemesisStatus.SUCCEEDED
-
-
-@dataclass(init=True, repr=True)
-class EventsBySeverity(ArgusUDTBase):
-    severity: str
-    event_amount: int
-    last_events: list[str]
-
-    @classmethod
-    def from_db_udt(cls, udt):
-        return cls(severity=udt.severity, event_amount=udt.event_amount, last_events=udt.last_events)
-
-
-TypeHint = TypeVar("TypeHint")
-
-
-@dataclass(init=True, repr=True)
-class CollectionHint:
-    stored_type: TypeHint
-
-
-@dataclass(init=True, repr=True)
-class ColumnInfo:
-    name: str
-    type: Type[Union[CollectionHint, int, str, TypeHint]]
-    value: Any
-    constraints: list[str]