backer-cli 0.1.1.dev0__tar.gz

backer_cli-0.1.1.dev0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: backer-cli
+Version: 0.1.1.dev0
+Summary: Backup control automation tool
+Author-email: lmriccardo <rlmarca.dev@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/lmriccardo/backer
+Project-URL: Repository, https://github.com/lmriccardo/backer
+Project-URL: Issues, https://github.com/lmriccardo/backer/issues
+Project-URL: Changelog, https://github.com/lmriccardo/backer/releases
+Keywords: backup,rsync,automation,cron,nas
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: System Administrators
+Classifier: Topic :: System :: Archiving :: Backup
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic[email]>=2.6
+Requires-Dist: croniter>=2.0
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: tabulate>=0.9
+Requires-Dist: requests>=2.32
+Requires-Dist: rich>=13.7
+Requires-Dist: aiohttp>=3.13
+Requires-Dist: packaging>=26.0
+
+# The Backer CLI application

backer_cli-0.1.1.dev0/README.md

@@ -0,0 +1 @@
+# The Backer CLI application

backer_cli-0.1.1.dev0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "backer-cli"
+version = "0.1.1-dev"
+description = "Backup control automation tool"
+readme = "README.md"
+requires-python = ">=3.12"
+keywords = ["backup","rsync","automation","cron","nas"]
+authors = [{ name = "lmriccardo", email = "rlmarca.dev@gmail.com" }]
+license = { text = "MIT" }
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: System Administrators",
+  "Topic :: System :: Archiving :: Backup",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Operating System :: POSIX :: Linux"
+]
+
+dependencies = [
+  "pydantic[email]>=2.6",
+  "croniter>=2.0",
+  "PyYAML>=6.0",
+  "tabulate>=0.9",
+  "requests>=2.32",
+  "rich>=13.7",
+  "aiohttp>=3.13",
+  "packaging>=26.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/lmriccardo/backer"
+Repository = "https://github.com/lmriccardo/backer"
+Issues = "https://github.com/lmriccardo/backer/issues"
+Changelog = "https://github.com/lmriccardo/backer/releases"
+
+[project.scripts]
+backer = "backer.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where=["src"]

backer_cli-0.1.1.dev0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

backer_cli-0.1.1.dev0/src/backer/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0-dev"

backer_cli-0.1.1.dev0/src/backer/__main__.py

@@ -0,0 +1,4 @@
+import backer.cli as cli
+
+if __name__ == "__main__":
+    raise SystemExit( cli.main() )

backer_cli-0.1.1.dev0/src/backer/apitypes.py

@@ -0,0 +1,21 @@
+from pydantic import BaseModel
+
+class ResponseModel(BaseModel): ...
+
+class VersionResponse(ResponseModel):
+    api        : int
+    commit     : str
+    date       : str
+    go_version : str
+    version    : str
+
+    def __str__(self) -> str:
+        return (
+            f"Daemon Version: backerd {self.version} " +
+            f"({self.commit}) built {self.date} " +
+            f"go={self.go_version}"
+        )
+
+class HealthzResponse(ResponseModel):
+    ok: bool
+    version: VersionResponse

backer_cli-0.1.1.dev0/src/backer/cli.py

@@ -0,0 +1,82 @@
+import argparse
+import asyncio
+import http
+import aiohttp.client_exceptions as httpexcept
+import backer.jobs as jobsfn
+import backer.http as httputils
+import backer.version as version
+
+CLIENT : httputils.BackerClient | None = None
+
+class UnreachableDaemonError(Exception):
+    def __init__(self) -> None: super().__init__()
+    def __str__(self) -> str:
+        return "Backer daemon is not reachable or it is not running"
+    
+async def _exec(parser: argparse.ArgumentParser) -> None:
+    # Parse the arguments
+    args = parser.parse_args()
+
+    global CLIENT
+    CLIENT = httputils.BackerClient(sock_path=httputils.get_unix_socket())
+    await CLIENT.create() # Create the session with the connector
+
+    # Before performing any command, check if the daemon
+    # is reachable by performing a simple healtz request.
+    resp = await CLIENT.make_request(httputils.Endpoints.Healthz)
+    if resp.code != http.HTTPStatus.OK or not resp.body.ok:
+        raise UnreachableDaemonError()
+    
+    # In the health message there is also the api version
+    endpoints = httputils.Endpoints()
+    endpoints.version(resp.body.version.api)
+
+    # If the --version option is given just returns the version
+    if args.version:
+        # Format the version and returns
+        print(resp.body.version)
+        await version.format_version()
+        return
+
+    # If the version is not given, but there is no
+    # command as well, just prints out the help msg
+    if args.command is None:
+        parser.print_help()
+        return 1
+    
+    _ = await args.func(args, CLIENT, endpoints)
+    return 0
+
+def def_jobs_command(parser: argparse._SubParsersAction) -> None:
+    # Top-level subparser
+    jobs_parser = parser.add_parser("jobs", help="Manage jobs")
+    jobs_subparser = jobs_parser.add_subparsers(dest="jobs_command", required=True)
+
+    # Jobs create command
+    create_parser = jobs_subparser.add_parser("create", help="Create a job")
+    create_parser.add_argument("config", help="YAML configuration file")
+    create_parser.set_defaults(func=jobsfn.handle_jobs_create)
+
+async def async_main() -> int:
+    parser = argparse.ArgumentParser(prog="backer", description="Backup automation control tool")
+    subparsers = parser.add_subparsers(dest="command")
+
+    # First add --version option to base parser
+    parser.add_argument("--version", required=False, action="store_true", help="Print out the version")
+
+    def_jobs_command(subparsers)
+
+    exit_code = 1
+
+    try:
+        exit_code = await _exec(parser)
+    except (httpexcept.ClientConnectorError, UnreachableDaemonError):
+        print(UnreachableDaemonError())
+    except Exception as e:
+        print(f"Error: {e} (type: {type(e)})")
+
+    await CLIENT.release()
+    return exit_code
+
+def main() -> int:
+    return asyncio.run(async_main())

backer_cli-0.1.1.dev0/src/backer/http.py

@@ -0,0 +1,124 @@
+"""
+Module with some useful functions to communicate
+with the backerd (the backer daemon) using its HTTP
+REST API. 
+"""
+from __future__ import annotations
+
+import os
+import aiohttp
+import aiohttp.typedefs
+import backer.apitypes as apitypes
+
+from enum import StrEnum
+from pathlib import Path
+from dataclasses import dataclass
+
+from typing import (
+    overload, Dict, Any, TypedDict, 
+    Unpack, TypeVar, Optional,
+    Type
+)
+
+_T = TypeVar('_T')
+
+SOCK_NAME = "backerd.sock"
+
+class _RequestOptions(TypedDict, total=False):
+    params: aiohttp.typedefs.Query
+    headers: Dict[str, Any]
+    body: Dict[str,Any]
+
+class HttpMethod(StrEnum):
+    NULL = ""
+    GET  = "GET"
+    POST = "POST"
+
+@dataclass(frozen=True)
+class Endpoint:
+    route  : str
+    method : HttpMethod = HttpMethod.NULL
+    model  : Optional[Type[apitypes.ResponseModel]] = None
+
+    @overload
+    def __truediv__(self, other: str) -> 'Endpoint': ...
+    @overload
+    def __truediv__(self, other: 'Endpoint') -> 'Endpoint': ...
+
+    def __truediv__(self, other) -> 'Endpoint':
+        if not (isinstance(other, str) or isinstance(other, Endpoint)):
+            return NotImplemented()
+
+        if isinstance(other, str):
+            # Input strings usually is for a route group, therefore
+            # we can leave the model and method to default None, NULL
+            return Endpoint(self.route + other)
+        
+        return Endpoint(self.route + other.route, other.method, other.model)
+    
+    def __eq__(self, other: 'Endpoint') -> bool:
+        return self.route  == other.route \
+           and self.method == other.method
+
+class Endpoints:
+    _Root    : Endpoint = Endpoint("/api")
+    Version  : Endpoint = _Root / Endpoint("/version", HttpMethod.GET, apitypes.VersionResponse)
+    Healthz  : Endpoint = _Root / Endpoint("/healthz", HttpMethod.GET, apitypes.HealthzResponse)
+
+    def __init__(self): self._version = "/v1"
+    def version(self, v: int) -> None:
+        self._version = f"/v{v}"
+    
+    @property
+    def _RootVers(self) -> Endpoint: return self._Root / self._version
+    @property
+    def Jobs(self) -> Endpoint: return self._RootVers / Endpoint("/jobs", HttpMethod.GET)
+    @property
+    def CreateJob(self) -> Endpoint: return self.Jobs / Endpoint("/create", HttpMethod.POST)
+
+@dataclass(frozen=True)
+class _Response[_T]:
+    code : int
+    body : _T
+
+def get_unix_socket() -> str:
+    """ Returns the unix socket for backerd """
+    basedir = os.getenv("XDG_RUNTIME_DIR")
+    return str(Path(basedir) / SOCK_NAME)
+
+class BackerClient:
+    def __init__(self, sock_path: str) -> None:
+        self._sock_path = sock_path
+        self._session: aiohttp.ClientSession | None = None
+
+    async def make_request(
+        self, endpoint: Endpoint, **kwargs: Unpack[_RequestOptions] 
+    ) -> _Response[_T | Dict[str,Any]]:
+        assert self._session is not None, "backer client must have a session"
+
+        resp = await self._session.request(
+            method=endpoint.method.value, url=f"http://localhost{endpoint.route}", **kwargs
+        )
+        
+        data = await resp.json() # Get the json body from the response
+        data = endpoint.model.model_validate(data)
+
+        custom_resp = _Response(resp.status, data)
+        resp.close() # Close the response before leaving
+        return custom_resp
+
+    async def create(self) -> None:
+        connector = aiohttp.UnixConnector(path=self._sock_path)
+        self._session = aiohttp.ClientSession(connector=connector)
+
+    async def release(self) -> None:
+        if self._session is None: return
+        await self._session.close()
+        self._session = None
+
+    async def __aenter__(self) -> 'BackerClient':
+        await self.create()
+        return self
+    
+    async def __aexit__(self, *args):
+        await self.release()

backer_cli-0.1.1.dev0/src/backer/jobs.py

@@ -0,0 +1,9 @@
+import argparse
+import backer.http as httputils
+
+async def handle_jobs_create(
+    args: argparse.Namespace, client: httputils.BackerClient, 
+    endpoints: httputils.Endpoints
+) -> None:
+    """ Handle the `backer jobs create <config>` command """
+    print("Create job called")

backer_cli-0.1.1.dev0/src/backer/version.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import aiohttp
+
+from packaging.version import Version
+from datetime import datetime
+from dataclasses import dataclass
+from typing import List, Tuple, TypeAlias
+from backer import __version__ as __in_version__
+from importlib.metadata import version, PackageNotFoundError
+
+__version__ = __in_version__
+try:
+    __version__ = version("backer-cli")
+except PackageNotFoundError:
+    ...
+
+RELEASE_API_URL = "https://pypi.org/simple/backer-cli/"
+
+@dataclass
+class RemoteFileInfo:
+    name: str
+    upload_time: datetime
+
+VersionList : TypeAlias = List[Version]
+FileList    : TypeAlias = List[RemoteFileInfo]
+
+async def _get_all_versions() -> Tuple[VersionList, FileList] | None:
+    """ Get the lastest version of the backupctl project """
+    headers = {'Host': 'pypi.org', 'Accept': 'application/vnd.pypi.simple.v1+json'}
+    timeout = aiohttp.ClientTimeout(total=10)
+
+    # Perform the async fetch operation and get back the payload
+    async with aiohttp.ClientSession(timeout=timeout, headers=headers) as session:
+        async with session.get(RELEASE_API_URL) as resp:
+            if resp.status < 200 or resp.status >= 300: return 
+            payload = await resp.json()
+
+    if not isinstance(payload, dict): return
+    if not "versions" in payload: return
+    if not isinstance(payload["versions"], list): return
+    if not "files" in payload: return
+
+    # First parse all files
+    version_list = list(map(Version, payload.get('versions')))
+    file_list = []
+    for file_data in payload.get("files"):
+        if not isinstance(file_data, dict): continue
+
+        file_name = file_data.get('filename')
+        upload_time = file_data.get('upload-time')
+
+        if not (isinstance(file_name, str) and isinstance(upload_time, str)):
+            continue
+
+        upload_time = datetime.fromisoformat(upload_time.replace("Z", "+00:00"))
+        file_list.append(RemoteFileInfo( file_name, upload_time ))
+        
+    return version_list, file_list
+
+def _get_latest_release( versions: VersionList ) -> Version:
+    """ Returns the lastest release """
+    return max( versions )
+
+def _get_release_time( version: Version, files: FileList ) -> datetime | None:
+    """ Return the date when the version has been released """
+    version_str = str(version) # Convert back to string
+    for fileitem in files:
+        if fileitem.name.startswith(f"backer-{version_str}"):
+            return fileitem.upload_time
+
+    return None
+
+async def format_version() -> None:
+    """ Format the version and get latest version """
+    curr_version = Version(__version__)
+    result = await _get_all_versions()
+    curr_version_time = None
+
+    if result is not None:
+        versions, files = result
+        curr_version_time = _get_release_time( curr_version, files )
+
+    # Print the current version
+    print(f"CLI Version: {curr_version} (", end="")
+    curr_t = "Not Yet Released" if curr_version_time is None else str(curr_version_time)
+    print(f"{curr_t})")
+
+    if result is not None:
+        last_version = _get_latest_release( versions )
+        last_version_time = _get_release_time( last_version, files )
+
+        # Print if there is a more recent version
+        if curr_version < last_version:
+            print(
+                "!! A new version is available - " +\
+                f"{last_version} ({last_version_time}) !!"
+            )
+            
+    print("")

backer_cli-0.1.1.dev0/src/backer_cli.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: backer-cli
+Version: 0.1.1.dev0
+Summary: Backup control automation tool
+Author-email: lmriccardo <rlmarca.dev@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/lmriccardo/backer
+Project-URL: Repository, https://github.com/lmriccardo/backer
+Project-URL: Issues, https://github.com/lmriccardo/backer/issues
+Project-URL: Changelog, https://github.com/lmriccardo/backer/releases
+Keywords: backup,rsync,automation,cron,nas
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: System Administrators
+Classifier: Topic :: System :: Archiving :: Backup
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic[email]>=2.6
+Requires-Dist: croniter>=2.0
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: tabulate>=0.9
+Requires-Dist: requests>=2.32
+Requires-Dist: rich>=13.7
+Requires-Dist: aiohttp>=3.13
+Requires-Dist: packaging>=26.0
+
+# The Backer CLI application

backer_cli-0.1.1.dev0/src/backer_cli.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/backer/__init__.py
+src/backer/__main__.py
+src/backer/apitypes.py
+src/backer/cli.py
+src/backer/http.py
+src/backer/jobs.py
+src/backer/version.py
+src/backer_cli.egg-info/PKG-INFO
+src/backer_cli.egg-info/SOURCES.txt
+src/backer_cli.egg-info/dependency_links.txt
+src/backer_cli.egg-info/entry_points.txt
+src/backer_cli.egg-info/requires.txt
+src/backer_cli.egg-info/top_level.txt

backer_cli-0.1.1.dev0/src/backer_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

backer_cli-0.1.1.dev0/src/backer_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+backer = backer.cli:main

backer_cli-0.1.1.dev0/src/backer_cli.egg-info/requires.txt

@@ -0,0 +1,8 @@
+pydantic[email]>=2.6
+croniter>=2.0
+PyYAML>=6.0
+tabulate>=0.9
+requests>=2.32
+rich>=13.7
+aiohttp>=3.13
+packaging>=26.0

backer_cli-0.1.1.dev0/src/backer_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+backer