fix StateHashFile encoding

Reviewed-on: #7
for #3

.gitea/workflows/docker.yml

@@ -0,0 +1,73 @@
+name: Docker Image CI
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - v*
+  pull_request:
+    branches:
+      - "master"
+
+jobs:
+  test:
+    runs-on: cth-ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build image
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: false
+          tags: gitea.b4tman.ru/b4tman/pddnsc:test
+  push:
+    needs: test
+    runs-on: cth-ubuntu-latest
+    if: github.event_name != 'pull_request'
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            gitea.b4tman.ru/b4tman/pddnsc
+          flavor: |
+            latest=${{ github.ref == 'refs/heads/master' }}
+          tags: |
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to gitea
+        uses: docker/login-action@v3
+        with:
+          registry: gitea.b4tman.ru
+          username: b4tman
+          password: ${{ secrets.PKGS_TOKEN }}
+
+      - name: Build and push image
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          #platforms: linux/amd64,linux/arm64
+          platforms: linux/amd64
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

README.md

@@ -2,13 +2,22 @@
 
 Возможно `DDNS` клиент
 
-## запуск
+## Запуск
 
 ~~~sh
 python -m pddnsc.cli
 ~~~
 
-## конфигурация
+либо в [docker](https://www.docker.com)/[podman](https://podman.io) (для запуска по расписанию в `cron`):
+
+~~~bash
+docker run -v .state:/app/state:rw \
+           -v .settings:/app/settings:ro \
+           -e SCHEDULE=@hourly \
+           gitea.b4tman.ru/b4tman/pddnsc
+~~~
+
+## Конфигурация
 
 Конфигурация находится в файле `settings/config.toml`.
 Пример конфигурации:
@@ -50,8 +59,22 @@ python -m pddnsc.cli
 - `filters` - фильтры, если хоть один вернет ложь то программа ничего никуда не запишет и не отправит, например проверка, что ip адрес не изменился
 - `outputs` - модули вывода, например вывод в консоль, запись в файл или создание dns записей на сервере
 
-Все модули источников/фильтров/вывода работают конкурентно через `asyncio`.
+Все модули источников/фильтров/вывода работают конкурентно через [asyncio](https://docs.python.org/3/library/asyncio.html#module-asyncio) и [httpx](https://www.python-httpx.org).
 
-### TODO
+### Подробная документация
 
-- Добавить названия python классов и их параметры.
+Её необходимо собрать с помошью [mkdocs](https://www.mkdocs.org). Для этого нужно установить зависимости:
+
+~~~bash
+pip install -r requirements.txt
+pip install -r requirements.docs.txt
+~~~
+
+После этого либо собрать документацию в каталог `site/`, либо запустить тестовый сервер.
+
+~~~bash
+# сборка
+mkdocs build
+# тестовый сервер
+mkdocs serve
+~~~

mkdocs.yml

@@ -20,5 +20,5 @@ plugins:
       config: mkapi_conf.py
 
 nav:
-  - Home: index.md
+  - Главная: index.md
-  - Reference: $api/pddnsc.***
+  - Справочник: $api/pddnsc.***

pddnsc/base.py

@@ -6,7 +6,7 @@ from httpx import AsyncHTTPTransport
 
 
 class IPAddreses(NamedTuple):
-    """набор из названия источника и IP адресов, результат одного из источников"""
+    """Набор из названия источника и IP адресов, результат одного из источников"""
 
     source_name: str
     ipv4: str
@@ -14,7 +14,7 @@ class IPAddreses(NamedTuple):
 
 
 class BaseSourceProvider(ABC):
-    """базовый класс для провайдеров источников"""
+    """Базовый класс для провайдеров источников"""
 
     _childs = {}
     registred = {}
@@ -35,14 +35,23 @@ class BaseSourceProvider(ABC):
         self.post_init()
 
     def post_init(self):
-        """метод для переопределения пост инициализации"""
+        """Метод для переопределения пост инициализации"""
         ...
 
     def __str__(self):
         return f"{self.__class__.__name__}: {self.name}"
 
+    def filter_ipv4(self, value: str) -> str:
+        """Функция для проверки валидности IPv4 адреса, возвращает "" если адрес неправильный или пустой"""
+        return value if value and valid_ipv4(value) else ""
+
+    def filter_ipv6(self, value: str) -> str:
+        """Функция для проверки валидности IPv6 адреса, возвращает "" если адрес неправильный или пустой"""
+        return value if value and valid_ipv6(value) else ""
+
     async def fetch_all(self) -> IPAddreses:
-        """метод для получения всех ip адресов сразу"""
+        """Метод для получения всех IP адресов сразу"""
+
         results = await asyncio.gather(
             self.fetch_v4(), self.fetch_v6(), return_exceptions=True
         )
@@ -51,13 +60,29 @@ class BaseSourceProvider(ABC):
             self.name, *("" if isinstance(i, Exception) else i for i in results)
         )
 
+    async def fetch_v4(self) -> str:
+        """Метод внешнего интерфейса для получения IPv4"""
+        result = await asyncio.gather(self.fetch_v4_impl(), return_exceptions=True)
+        ipv4 = ""
+        if not isinstance(result[0], Exception):
+            ipv4 = result[0]
+        return self.filter_ipv4(ipv4)
+
+    async def fetch_v6(self) -> str:
+        """Метод внешнего интерфейса для получения IPv6"""
+        result = await asyncio.gather(self.fetch_v6_impl(), return_exceptions=True)
+        ipv6 = ""
+        if not isinstance(result[0], Exception):
+            ipv6 = result[0]
+        return self.filter_ipv6(ipv6)
+
     def __init_subclass__(cls) -> None:
         BaseSourceProvider._childs[cls.__name__] = cls
         return super().__init_subclass__()
 
     @classmethod
     def validate_source_config(cls, name: str, config: dict):
-        """метод валидации конфигурации для провайдера"""
+        """Метод валидации конфигурации для провайдера"""
         if "provider" not in config:
             return False
         prov_name = config["provider"]
@@ -73,7 +98,7 @@ class BaseSourceProvider(ABC):
         ipv4t: AsyncHTTPTransport,
         ipv6t: AsyncHTTPTransport,
     ):
-        """метод регистрации провайдера по конфигурации"""
+        """Метод регистрации провайдера по конфигурации"""
 
         if not cls.validate_source_config(name, config):
             return
@@ -81,18 +106,18 @@ class BaseSourceProvider(ABC):
         cls.registred[name] = provider(name, config, ipv4t, ipv6t)
 
     @abstractmethod
-    async def fetch_v4(self) -> str:
+    async def fetch_v4_impl(self) -> Optional[str]:
-        """необходимый метод для реализации получения ipv4"""
+        """Необходимый метод для реализации получения IPv4"""
         ...
 
     @abstractmethod
-    async def fetch_v6(self) -> str:
+    async def fetch_v6_impl(self) -> Optional[str]:
-        """необходимый метод для реализации получения ipv6"""
+        """Необходимый метод для реализации получения IPv6"""
         ...
 
 
 class BaseOutputProvider(ABC):
-    """базовый класс для провайдеров вывода"""
+    """Базовый класс для провайдеров вывода"""
 
     _childs = {}
     registred = {}
@@ -109,7 +134,7 @@ class BaseOutputProvider(ABC):
         self.post_init()
 
     def post_init(self):
-        """метод для переопределения пост инициализации"""
+        """Метод для переопределения пост инициализации"""
         ...
 
     def __init_subclass__(cls) -> None:
@@ -120,14 +145,14 @@ class BaseOutputProvider(ABC):
         return f"{self.__class__.__name__}: {self.name}"
 
     def best_transport(self, addr_v4: str, addr_v6: str) -> AsyncHTTPTransport:
-        """метод выбирает лучший транспорт для отправки адресов (либо ipv4 либо ipv6)"""
+        """Метод выбирает лучший транспорт для отправки адресов (либо ipv4 либо ipv6)"""
         if addr_v6:
             return self.ipv6t
         return self.ipv4t
 
     @classmethod
     def validate_source_config(cls, name: str, config: dict):
-        """метод валидации конфигурации для провайдера"""
+        """Метод валидации конфигурации для провайдера"""
 
         if "provider" not in config:
             return False
@@ -144,24 +169,24 @@ class BaseOutputProvider(ABC):
         ipv4t: AsyncHTTPTransport,
         ipv6t: AsyncHTTPTransport,
     ):
-        """метод регистрации провайдера по конфигурации"""
+        """Метод регистрации провайдера по конфигурации"""
         if not cls.validate_source_config(name, config):
             return
         provider = cls._childs[config["provider"]]
         cls.registred[name] = provider(name, config, ipv4t, ipv6t)
 
     async def set_addrs(self, source_provider: str, addr_v4: str, addr_v6: str):
-        """метод внешнего интерфейса для отправки адресов"""
+        """Метод внешнего интерфейса для отправки адресов"""
         return await self.set_addrs_imp(source_provider, addr_v4, addr_v6)
 
     @abstractmethod
     async def set_addrs_imp(self, source_provider: str, addr_v4: str, addr_v6: str):
-        """необходимый метод для реализации отправки/вывода IP аддресов"""
+        """Необходимый метод для реализации отправки/вывода IP аддресов"""
         ...
 
 
 class BaseFilterProvider(ABC):
-    """базовый класс для провайдеров фильтров"""
+    """Базовый класс для провайдеров фильтров"""
 
     _childs = {}
     registred = {}
@@ -178,7 +203,7 @@ class BaseFilterProvider(ABC):
         self.post_init()
 
     def post_init(self):
-        """метод для переопределения пост инициализации"""
+        """Метод для переопределения пост инициализации"""
         ...
 
     def __init_subclass__(cls) -> None:
@@ -190,7 +215,7 @@ class BaseFilterProvider(ABC):
 
     @classmethod
     def validate_source_config(cls, name: str, config: dict) -> bool:
-        """метод валидации конфигурации для провайдера"""
+        """Метод валидации конфигурации для провайдера"""
 
         if "provider" not in config:
             return False
@@ -207,7 +232,7 @@ class BaseFilterProvider(ABC):
         ipv4t: AsyncHTTPTransport,
         ipv6t: AsyncHTTPTransport,
     ):
-        """метод регистрации провайдера по конфигурации"""
+        """Метод регистрации провайдера по конфигурации"""
 
         if not cls.validate_source_config(name, config):
             return
@@ -215,20 +240,10 @@ class BaseFilterProvider(ABC):
         cls.registred[name] = provider(name, config, ipv4t, ipv6t)
 
     async def check(self, source_provider: str, addr_v4: str, addr_v6: str) -> bool:
-        """метод внешнего интерфейса для проверки адресов"""
+        """Метод внешнего интерфейса для проверки адресов"""
         return await self.check_imp(source_provider, addr_v4, addr_v6)
 
     @abstractmethod
     async def check_imp(self, source_provider: str, addr_v4: str, addr_v6: str) -> bool:
-        """необходимый метод реализации проверки"""
+        """Необходимый метод реализации проверки"""
         ...
-
-
-def filter_ipv4(value: str) -> Optional[str]:
-    """функция для проверки валидности IPv4 адреса, возвращает None если адрес неправильный или пустой"""
-    return value and valid_ipv4(value) and value or None
-
-
-def filter_ipv6(value: str) -> Optional[str]:
-    """функция для проверки валидности IPv6 адреса, возвращает None если адрес неправильный или пустой"""
-    return value and valid_ipv6(value) and value or None

pddnsc/cli.py

@@ -1,163 +1,10 @@
 """ модуль запуска """
 
 import httpx
-import asyncio
 import toml
-from .base import BaseFilterProvider, BaseSourceProvider, BaseOutputProvider, IPAddreses
+import asyncio
-from .plugins import use_plugins
-from typing import Optional
 
-
+from pddnsc.core import app
-def is_valid_addreses(addrs: IPAddreses, config: dict) -> bool:
-    """Проверка валидности IP адресов
-
-    Args:
-        addrs (IPAddreses): IP адреса - результат одного из источников
-        config (dict): общая конфигурация
-
-    Returns:
-        bool: валиден или нет
-    """
-    result = addrs.ipv4 or addrs.ipv6
-    if config.get("require_ipv4"):
-        result = result and addrs.ipv4
-    if config.get("require_ipv6"):
-        result = result and addrs.ipv6
-    return result
-
-
-async def get_ip_addresses(config: dict) -> Optional[IPAddreses]:
-    """Получение всех IP адресов из всех источников
-
-    Args:
-        config (dict): общая конфигурация
-
-    Returns:
-        Optional[IPAddreses]: результат получения, либо None
-    """
-    providers = BaseSourceProvider.registred.values()
-    ip_addresses = None
-    is_done = False
-    pending = [asyncio.create_task(p.fetch_all(), name=p.name) for p in providers]
-    while not is_done and pending:
-        done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
-        for x in done:
-            ip_addresses = x.result()
-            if is_valid_addreses(ip_addresses, config):
-                is_done = True
-                break
-            ip_addresses = None
-
-    if pending:
-        gather = asyncio.gather(*pending)
-        gather.cancel()
-        try:
-            await gather
-        except asyncio.CancelledError:
-            pass
-    return ip_addresses
-
-
-async def check_ip_addresses(ip_addresses: IPAddreses) -> bool:
-    """Проверка результата получения IP адресов с помощью фильтров
-
-    Args:
-        ip_addresses (IPAddreses): IP адреса
-
-    Returns:
-        bool: корректны ли адреса (изменились ли они),
-              надо ли продолжать обработку и отправлять их на сервер
-    """
-    providers = BaseFilterProvider.registred.values()
-    result = True
-    failed = ""
-    pending = [
-        asyncio.create_task(p.check(*ip_addresses), name=p.name) for p in providers
-    ]
-    while result and pending:
-        done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
-        for x in done:
-            result = x.result()
-            if not result:
-                failed = x.get_name()
-
-    if pending:
-        gather = asyncio.gather(*pending)
-        gather.cancel()
-        try:
-            await gather
-        except asyncio.CancelledError:
-            pass
-
-    if not result:
-        print("failed filter:", failed)
-
-    return result
-
-
-async def send_ip_addreses(ip_addresses: IPAddreses):
-    """Отправка адресов на все плагины вывода
-
-    Args:
-        ip_addresses (IPAddreses): IP адреса
-    """
-    providers = BaseOutputProvider.registred.values()
-    await asyncio.gather(
-        *(
-            asyncio.create_task(p.set_addrs(*ip_addresses), name=p.name)
-            for p in providers
-        )
-    )
-
-
-def print_debug_info(config: dict):
-    """Вывод всех зарегистрированных плагинов и другой отладочной информации"""
-    debug = config.get("debug", False)
-    if debug:
-        print("DEBUG info:")
-        print(
-            f"source classes: {[*BaseSourceProvider._childs]}, {[*map(str, BaseSourceProvider._childs.values())]}"
-        )
-        print(
-            f"filter classes: {[*BaseFilterProvider._childs]}, {[*map(str, BaseFilterProvider._childs.values())]}"
-        )
-        print(
-            f"output classes: {[*BaseOutputProvider._childs]}, {[*map(str, BaseOutputProvider._childs.values())]}"
-        )
-        print(
-            f"source providers: {[*BaseSourceProvider.registred]}, {[*map(str, BaseSourceProvider.registred.values())]}"
-        )
-        print(
-            f"filter providers: {[*BaseFilterProvider.registred]}, {[*map(str, BaseFilterProvider.registred.values())]}"
-        )
-        print(
-            f"output providers: {[*BaseOutputProvider.registred]}, {[*map(str, BaseOutputProvider.registred.values())]}"
-        )
-
-
-async def app(
-    config: dict, ipv4t: httpx.AsyncHTTPTransport, ipv6t: httpx.AsyncHTTPTransport
-):
-    """Запуск приложения
-
-    Args:
-        config (dict): общая конфигурация
-        ipv4t (httpx.AsyncHTTPTransport): транспорт IPv4
-        ipv6t (httpx.AsyncHTTPTransport): транспорт IPv6
-    """
-    use_plugins(config, ipv4t, ipv6t)
-
-    print_debug_info(config)
-
-    ip_addreses = await get_ip_addresses(config)
-    if ip_addreses is None:
-        print("no IP addresses")
-        return
-    if not await check_ip_addresses(ip_addreses):
-        print("stop by filters")
-        return
-    await send_ip_addreses(ip_addreses)
-    print("done")
 
 
 async def main():

pddnsc/core.py

@@ -0,0 +1,285 @@
+import httpx
+import asyncio
+from .base import BaseFilterProvider, BaseSourceProvider, BaseOutputProvider, IPAddreses
+from .plugins import use_plugins
+from typing import Optional, NamedTuple
+
+
+class NeededAddrs(NamedTuple):
+    ipv4: bool
+    ipv6: bool
+
+    @classmethod
+    def from_config(cls, config: dict) -> "NeededAddrs":
+        need_ipv4 = config.get("require_ipv4", False)
+        need_ipv6 = config.get("require_ipv6", False)
+        if "require_ipv4" not in config and "require_ipv6" not in config:
+            need_ipv4 = need_ipv6 = True
+        return cls(need_ipv4, need_ipv6)
+
+
+def is_valid_addreses(addrs: IPAddreses, config: dict) -> bool:
+    """Проверка валидности IP адресов
+
+    Args:
+        addrs (IPAddreses): IP адреса - результат одного из источников
+        config (dict): общая конфигурация
+
+    Returns:
+        bool: валиден или нет
+    """
+    result = addrs.ipv4 or addrs.ipv6
+    if config.get("require_ipv4"):
+        result = result and addrs.ipv4
+    if config.get("require_ipv6"):
+        result = result and addrs.ipv6
+    return bool(result)
+
+
+def is_ipv4_ok(ipv4: str, config: dict) -> bool:
+    """Проверка IPv4 адреса, подходит или нет
+
+    Args:
+        ipv4 (str): IPv4 адрес
+        config (dict): общая конфигурация
+
+    Returns:
+        bool: подходит или нет
+    """
+    return bool(ipv4) if NeededAddrs.from_config(config).ipv4 else True
+
+
+def is_ipv6_ok(ipv6: str, config: dict) -> bool:
+    """Проверка IPv6 адреса, подходит или нет
+
+    Args:
+        ipv6 (str): IPv6 адрес
+        config (dict): общая конфигурация
+
+    Returns:
+        bool: подходит или нет
+    """
+    return bool(ipv6) if NeededAddrs.from_config(config).ipv6 else True
+
+
+async def get_ip_addresses(config: dict) -> Optional[IPAddreses]:
+    """Получение всех IP адресов из всех источников
+
+    Args:
+        config (dict): общая конфигурация
+
+    Returns:
+        Optional[IPAddreses]: результат получения, либо None
+    """
+
+    unit_mode = config.get("unit_mode", False)
+    if unit_mode:
+        result = await get_ip_addresses_unit(config)
+    else:
+        result = await get_ip_addresses_any(config)
+    return result
+
+
+async def get_ip_addresses_any(config: dict) -> Optional[IPAddreses]:
+    """Получение всех IP адресов из всех источников (режим any)
+
+    Получает разные адреса от любых источников
+
+    Args:
+        config (dict): общая конфигурация
+
+    Returns:
+        Optional[IPAddreses]: результат получения, либо None
+    """
+    need = NeededAddrs.from_config(config)
+    providers = BaseSourceProvider.registred.values()
+    ip_addresses, is_done = None, False
+    last_src, last_ipv4, last_ipv6 = "", "", ""
+    ok_ipv4, ok_ipv6 = False, False
+    drop = []
+    pending = []
+    if need.ipv4:
+        pending += [
+            asyncio.create_task(p.fetch_v4(), name=f"{p.name}.v4") for p in providers
+        ]
+    if need.ipv6:
+        pending += [
+            asyncio.create_task(p.fetch_v6(), name=f"{p.name}.v6") for p in providers
+        ]
+    while not is_done and pending:
+        done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
+        for x in done:
+            ip_addr = x.result()
+            if x.get_name().endswith(".v6"):
+                last_ipv6 = last_ipv6 if ok_ipv6 else ip_addr
+            else:
+                last_ipv4 = last_ipv4 if ok_ipv4 else ip_addr
+            if config.get("debug"):
+                print("debug:", "get", x.get_name(), ip_addr)
+            last_src = x.get_name().rsplit(".", maxsplit=1)[0]
+            ok_ipv4 = is_ipv4_ok(last_ipv4, config)
+            ok_ipv6 = is_ipv6_ok(last_ipv6, config)
+            pending_v4 = [*filter(lambda i: i.get_name().endswith(".v4"), pending)]
+            pending_v6 = [*filter(lambda i: i.get_name().endswith(".v6"), pending)]
+            if ok_ipv4 and pending_v4:
+                drop += pending_v4
+                pending = pending_v6
+                for i in pending_v4:
+                    i.cancel()
+                pending_v4 = []
+            if ok_ipv6 and pending_v6:
+                drop += pending_v6
+                pending = pending_v4
+                for i in pending_v6:
+                    i.cancel()
+                pending_v6 = []
+            if not (ok_ipv4 and ok_ipv6):
+                continue
+            ip_addresses = IPAddreses(last_src, last_ipv4, last_ipv6)
+            if is_valid_addreses(ip_addresses, config):
+                is_done = True
+                break
+            ip_addresses = None
+
+    if not (ok_ipv4 and ok_ipv6):
+        ip_addresses = IPAddreses(last_src, last_ipv4, last_ipv6)
+
+    drop = drop + list(pending)
+    if drop:
+        gather = asyncio.gather(*drop)
+        gather.cancel()
+        try:
+            await gather
+        except asyncio.CancelledError:
+            pass
+    return ip_addresses
+
+
+async def get_ip_addresses_unit(config: dict) -> Optional[IPAddreses]:
+    """Получение всех IP адресов из всех источников (режим unit)
+
+    Получает адреса только от одного источника
+
+    Args:
+        config (dict): общая конфигурация
+
+    Returns:
+        Optional[IPAddreses]: результат получения, либо None
+    """
+    providers = BaseSourceProvider.registred.values()
+    ip_addresses = None
+    is_done = False
+    pending = [asyncio.create_task(p.fetch_all(), name=p.name) for p in providers]
+    while not is_done and pending:
+        done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
+        for x in done:
+            ip_addresses = x.result()
+            if is_valid_addreses(ip_addresses, config):
+                is_done = True
+                break
+            ip_addresses = None
+
+    if pending:
+        gather = asyncio.gather(*pending)
+        gather.cancel()
+        try:
+            await gather
+        except asyncio.CancelledError:
+            pass
+    return ip_addresses
+
+
+async def check_ip_addresses(ip_addresses: IPAddreses) -> bool:
+    """Проверка результата получения IP адресов с помощью фильтров
+
+    Args:
+        ip_addresses (IPAddreses): IP адреса
+
+    Returns:
+        bool: корректны ли адреса (изменились ли они),
+              надо ли продолжать обработку и отправлять их на сервер
+    """
+    providers = BaseFilterProvider.registred.values()
+    result = True
+    failed = ""
+    pending = [
+        asyncio.create_task(p.check(*ip_addresses), name=p.name) for p in providers
+    ]
+    while result and pending:
+        done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
+        for x in done:
+            result = x.result()
+            if not result:
+                failed = x.get_name()
+
+    if pending:
+        gather = asyncio.gather(*pending)
+        gather.cancel()
+        try:
+            await gather
+        except asyncio.CancelledError:
+            pass
+
+    if not result:
+        print("failed filter:", failed)
+
+    return result
+
+
+async def send_ip_addreses(ip_addresses: IPAddreses):
+    """Отправка адресов на все плагины вывода
+
+    Args:
+        ip_addresses (IPAddreses): IP адреса
+    """
+    providers = BaseOutputProvider.registred.values()
+    await asyncio.gather(
+        *(
+            asyncio.create_task(p.set_addrs(*ip_addresses), name=p.name)
+            for p in providers
+        )
+    )
+
+
+def print_debug_info(config: dict):
+    """Вывод всех зарегистрированных плагинов и другой отладочной информации"""
+
+    def format_registred(name, base):
+        result = f"{name}:\n"
+        result += f"  classes: {[*base._childs]}\n"
+        result += f"  .values: {[*map(str, base._childs.values())]}\n"
+        result += f"  providers: {[*base.registred]}\n"
+        result += f"  .values: {[*map(str, base.registred.values())]}\n"
+        return result
+
+    if config.get("debug", False):
+        print("DEBUG ->")
+        bases = BaseSourceProvider, BaseFilterProvider, BaseOutputProvider
+        for info in map(format_registred, "sources filters outputs".split(), bases):
+            print(info)
+        print("DEBUG <-")
+
+
+async def app(
+    config: dict, ipv4t: httpx.AsyncHTTPTransport, ipv6t: httpx.AsyncHTTPTransport
+):
+    """Запуск приложения
+
+    Args:
+        config (dict): общая конфигурация
+        ipv4t (httpx.AsyncHTTPTransport): транспорт IPv4
+        ipv6t (httpx.AsyncHTTPTransport): транспорт IPv6
+    """
+    use_plugins(config, ipv4t, ipv6t)
+
+    print_debug_info(config)
+
+    ip_addreses = await get_ip_addresses(config)
+    if ip_addreses is None:
+        print("no IP addresses")
+        return
+    if not await check_ip_addresses(ip_addreses):
+        print("stop by filters")
+        return
+    await send_ip_addreses(ip_addreses)
+    print("done")

pddnsc/filters/files.py

@@ -1,4 +1,3 @@
-import asyncio
 import hashlib
 import json
 import aiofiles
@@ -7,63 +6,79 @@ from os.path import isfile
 from pddnsc.base import BaseFilterProvider
 
 
-class StateHashFilter(BaseFilterProvider):
+class GenericTextFileFilter(BaseFilterProvider):
-    """Проверка на то что хотябы один IP адрес изменился по хешу сохраненному в файле
+    """Проверка на то что хотябы один IP адрес изменился по сравнению с текстом в файле
 
     Конфигурация:
 
       - filepath: имя файла
+      - encoding: кодировка, по умолчанию "utf-8"
+      - mode: режим открытия, по умолчанию "r"
+      - check_ipv4: проверять ли IPv4, по умолчанию нет если check_ipv6 есть в конфиге иначе да
+      - check_ipv6: проверять ли IPv6, по умолчанию нет если check_ipv4 есть в конфиге иначе да
     """
 
-    async def check_imp(self, source_provider: str, addr_v4: str, addr_v6: str) -> bool:
+    def post_init(self):
-        if not isfile(self.config["filepath"]):
+        super().post_init()
-            return True
+        self.filepath = self.config["filepath"]
+        self.encoding = self.config.get("encoding", "utf-8")
+        self.mode = self.config.get("mode", "r")
+        self.check_ipv4 = self.config.get("check_ipv4", False)
+        self.check_ipv6 = self.config.get("check_ipv6", False)
+        if "check_ipv4" not in self.config and "check_ipv4" not in self.config:
+            self.check_ipv4 = self.check_ipv6 = True
+        self.content = ""
 
-        new_state_str = (addr_v4 or "") + (addr_v6 or "")
+    async def read(self) -> str:
-        new_sha = hashlib.sha256(new_state_str.encode(encoding="utf-8"))
         async with aiofiles.open(
-            self.config["filepath"], mode="r", encoding="utf-8"
+            self.filepath, mode=self.mode, encoding=self.encoding
         ) as f:
-            old_state_hash = await f.read()
+            self.content = await f.read()
-
-        return old_state_hash != new_sha.hexdigest()
-
-
-class StateFileFilter(BaseFilterProvider):
-    """Проверка на то что хотябы один IP адрес изменился по сравнению с данными в json файле
-
-    Конфигурация:
-
-      - filepath: имя файла
-      - check_ipv4: проверка ipv4 адреса
-      - check_ipv6: проверка ipv6 адреса
-
-      если нет ни одного параметра то проверка выполняется для всех адресов
-    """
 
     async def check_imp(self, source_provider: str, addr_v4: str, addr_v6: str) -> bool:
-        if not isfile(self.config["filepath"]):
+        lst = []
+        if self.check_ipv4:
+            lst.append(addr_v4)
+        if self.check_ipv4:
+            lst.append(addr_v6)
+        new_content = "\n".join(lst)
+        return new_content != self.content
+
+    async def check(self, source_provider: str, addr_v4: str, addr_v6: str) -> bool:
+        if not isfile(self.filepath):
             return True
+        await self.read()
+        return await self.check_imp(source_provider, addr_v4, addr_v6)
 
-        new_state = {
-            "ipv4": addr_v4,
-            "ipv6": addr_v6,
-        }
 
-        async with aiofiles.open(
+class StateHashFilter(GenericTextFileFilter):
-            self.config["filepath"], mode="r", encoding="utf-8"
+    """Проверка на то что хотябы один IP адрес изменился по хешу сохраненному в файле"""
-        ) as f:
-            old_state = json.loads(await f.read())
 
+    async def check_imp(self, source_provider: str, addr_v4: str, addr_v6: str) -> bool:
+        new_state_str = (self.check_ipv4 and addr_v4 or "") + (
+            self.check_ipv6 and addr_v6 or ""
+        )
+        new_sha = hashlib.sha256(new_state_str.encode(encoding=self.encoding))
+        return self.content != new_sha.hexdigest()
+
+
+class StateFileFilter(GenericTextFileFilter):
+    """Проверка на то что хотябы один IP адрес изменился по сравнению с данными в json файле"""
+
+    async def check_imp(self, source_provider: str, addr_v4: str, addr_v6: str) -> bool:
+        new_state = {}
+        if self.check_ipv4:
+            new_state["ipv4"] = addr_v4 or ""
+        if self.check_ipv6:
+            new_state["ipv6"] = addr_v6 or ""
+
+        old_state = json.loads(self.content)
         result = True
 
-        if "check_ipv4" not in self.config and "check_ipv4" not in self.config:
+        if self.check_ipv4:
-            return new_state != old_state
-
-        if self.config.get("check_ipv4", False):
             result = result and new_state["ipv4"] != old_state["ipv4"]
 
-        if self.config.get("check_ipv6", False):
+        if self.check_ipv6:
             result = result and new_state["ipv6"] != old_state["ipv6"]
 
         return result

pddnsc/outputs/files.py

@@ -5,38 +5,70 @@ import hashlib
 from pddnsc.base import BaseOutputProvider
 
 
-class StateFile(BaseOutputProvider):
+class GenericTextFile(BaseOutputProvider):
-    """Схранение всех IP адресов в json файл
+    """Сохранение IP адресов в текстовый файл
 
     Конфигурация:
 
       - filepath: имя файла
+      - encoding: кодировка, по умолчанию "utf-8"
+      - mode: режим открытия, по умолчанию "w"
+      - save_ipv4: сохранять ли IPv4, по умолчанию нет если save_ipv6 есть в конфиге иначе да
+      - save_ipv6: сохранять ли IPv6, по умолчанию нет если save_ipv4 есть в конфиге иначе да
     """
 
-    async def set_addrs_imp(self, source_provider: str, addr_v4: str, addr_v6: str):
+    def post_init(self):
-        state = {
+        super().post_init()
-            "ipv4": addr_v4 or "",
+        self.filepath = self.config["filepath"]
-            "ipv6": addr_v6 or "",
+        self.encoding = self.config.get("encoding", "utf-8")
-        }
+        self.mode = self.config.get("mode", "w")
-        state_str = json.dumps(state)
+        self.save_ipv4 = self.config.get("save_ipv4", False)
+        self.save_ipv6 = self.config.get("save_ipv6", False)
+        if "save_ipv4" not in self.config and "save_ipv4" not in self.config:
+            self.save_ipv4 = self.save_ipv6 = True
+        self.content = ""
+
+    async def read(self):
+        async with aiofiles.open(self.filepath, mode="r", encoding=self.encoding) as f:
+            self.content = await f.read()
+
+    def set_content(self, ipv4: str, ipv6: str):
+        lst = []
+        if self.save_ipv4:
+            lst.append(ipv4)
+        if self.save_ipv6:
+            lst.append(ipv6)
+        self.content = "\n".join(lst)
+
+    async def write(self):
         async with aiofiles.open(
-            self.config["filepath"], mode="w", encoding="utf-8"
+            self.filepath, mode=self.mode, encoding=self.encoding
         ) as f:
-            await f.write(state_str)
+            await f.write(self.content)
-
-
-class StateHashFile(BaseOutputProvider):
-    """Сохранение хеша от всех IP адресов в файл
-
-    Конфигурация:
-
-      - filepath: имя файла
-    """
 
     async def set_addrs_imp(self, source_provider: str, addr_v4: str, addr_v6: str):
-        state_str = (addr_v4 or "") + (addr_v6 or "")
+        await self.set_content(addr_v4, addr_v6)
-        sha = hashlib.sha256(state_str.encode(encoding="utf-8"))
+        await self.write()
-        async with aiofiles.open(
+
-            self.config["filepath"], mode="w", encoding="utf-8"
+
-        ) as f:
+class StateFile(GenericTextFile):
-            await f.write(sha.hexdigest())
+    """Сохранение всех IP адресов в json файл"""
+
+    async def set_content(self, addr_v4: str, addr_v6: str):
+        state = {}
+        if self.save_ipv4:
+            state["ipv4"] = addr_v4 or ""
+        if self.save_ipv6:
+            state["ipv6"] = addr_v6 or ""
+        self.content = json.dumps(state)
+
+
+class StateHashFile(GenericTextFile):
+    """Сохранение хеша от всех IP адресов в файл"""
+
+    async def set_content(self, addr_v4: str, addr_v6: str):
+        state_str = (self.save_ipv4 and addr_v4 or "") + (
+            self.save_ipv6 and addr_v6 or ""
+        )
+        sha = hashlib.sha256(state_str.encode(encoding=self.encoding))
+        self.content = sha.hexdigest()

pddnsc/plugins.py

@@ -3,23 +3,28 @@
 from httpx import AsyncHTTPTransport
 from .base import BaseSourceProvider, BaseFilterProvider, BaseOutputProvider
 from . import sources
-from . import outputs
 from . import filters
+from . import outputs
+
+
+def unused():
+    """Чтобы убрать предупреждение о неиспользуемых импортах"""
+    return sources, filters, outputs
 
 
 def use_plugins(config: dict, ipv4t: AsyncHTTPTransport, ipv6t: AsyncHTTPTransport):
     """Регистрация всех плагинов указаных в конфигурации"""
-    for source_name in config["sources"]:
+    for source_name in config.get("sources", []):
         BaseSourceProvider.register_provider(
             source_name, config["sources"][source_name], ipv4t, ipv6t
         )
 
-    for filter_name in config["filters"]:
+    for filter_name in config.get("filters", []):
         BaseFilterProvider.register_provider(
             filter_name, config["filters"][filter_name], ipv4t, ipv6t
         )
 
-    for output_name in config["outputs"]:
+    for output_name in config.get("outputs", []):
         BaseOutputProvider.register_provider(
             output_name, config["outputs"][output_name], ipv4t, ipv6t
         )

pddnsc/sources/fake.py

@@ -6,27 +6,33 @@ from pddnsc.base import BaseSourceProvider
 
 
 class DummySource(BaseSourceProvider):
-    """имитация получения пустых адресов"""
+    """Имитация получения пустых адресов"""
 
-    async def fetch_v4(self) -> str:
+    async def fetch_v4_impl(self) -> str:
         result = await asyncio.sleep(self.config.get("delay", 1), result="")
         return result
 
-    async def fetch_v6(self) -> str:
+    async def fetch_v6_impl(self) -> str:
         result = await asyncio.sleep(self.config.get("delay", 1), result="")
         return result
 
 
 class FakeSource(BaseSourceProvider):
-    """имитация получения заданных в конфигурации адресов"""
+    """Имитация получения заданных в конфигурации адресов
 
-    async def fetch_v4(self) -> str:
+    Конфигурация:
+
+    - ipv4: строка IPv4, по умолчанию "127.0.0.1"
+    - ipv6: строка IPv6, по умолчанию "::1"
+    """
+
+    async def fetch_v4_impl(self) -> str:
         result = await asyncio.sleep(
             self.config.get("delay", 1), result=self.config.get("ipv4", "127.0.0.1")
         )
         return result
 
-    async def fetch_v6(self) -> str:
+    async def fetch_v6_impl(self) -> str:
         result = await asyncio.sleep(
             self.config.get("delay", 1), result=self.config.get("ipv6", "::1")
         )

pddnsc/sources/http.py

@@ -1,6 +1,7 @@
+from typing import Optional
 import httpx
 
-from pddnsc.base import BaseSourceProvider, filter_ipv4, filter_ipv6
+from pddnsc.base import BaseSourceProvider
 
 
 class GenericHttpSource(BaseSourceProvider):
@@ -18,7 +19,7 @@ class GenericHttpSource(BaseSourceProvider):
         self.url_v6 = self.config.get("url_v6")
         self.headers = self.config.get("headers", {})
 
-    async def fetch_v4(self) -> str:
+    async def fetch_v4_impl(self) -> Optional[str]:
         if not self.url_v4:
             return None
 
@@ -29,9 +30,9 @@ class GenericHttpSource(BaseSourceProvider):
             response = await client.get(self.url_v4)
             if response.is_success:
                 result = response.text.strip()
-        return filter_ipv4(result)
+        return result
 
-    async def fetch_v6(self) -> str:
+    async def fetch_v6_impl(self) -> Optional[str]:
         if not self.url_v6:
             return None
 
@@ -42,7 +43,7 @@ class GenericHttpSource(BaseSourceProvider):
             response = await client.get(self.url_v6)
             if response.is_success:
                 result = response.text.strip()
-        return filter_ipv6(result)
+        return result
 
 
 class GenericHttpJsonSource(BaseSourceProvider):
@@ -68,7 +69,7 @@ class GenericHttpJsonSource(BaseSourceProvider):
             headers = {}
         self.headers = headers.update(self.config.get("headers", {}))
 
-    async def fetch_v4(self) -> str:
+    async def fetch_v4_impl(self) -> Optional[str]:
         if not self.url_v4 or self.key_v4 is None:
             return None
 
@@ -79,9 +80,9 @@ class GenericHttpJsonSource(BaseSourceProvider):
             response = await client.get(self.url_v4)
             if response.is_success:
                 result = response.json()[self.key_v4].strip()
-        return filter_ipv4(result)
+        return result
 
-    async def fetch_v6(self) -> str:
+    async def fetch_v6_impl(self) -> Optional[str]:
         if not self.url_v6 or self.key_v6 is None:
             return None
 
@@ -92,4 +93,4 @@ class GenericHttpJsonSource(BaseSourceProvider):
             response = await client.get(self.url_v6)
             if response.is_success:
                 result = response.json()[self.key_v6].strip()
-        return filter_ipv6(result)
+        return result

pddnsc/sources/httpregex.py

@@ -0,0 +1,33 @@
+import re
+
+from pddnsc.sources.http import GenericHttpSource
+
+
+class GenericHttpRegexSource(GenericHttpSource):
+    """Базовый провайдер получения IP адресов по http/https ссылкам в виде текста c помощью регулярных выражений
+
+    Конфигурация:
+
+      - url_v4: *URL* для получения адреса *IPv4*
+      - url_v6: *URL* для получения адреса *IPv6*
+      - regex_v4: регулярное выражение для *IPv4*, значение по умолчанию см. в коде
+      - regex_v6: регулярное выражение для *IPv6*, значение по умолчанию см. в коде
+      - headers (`dict`): словарь дополнительных заголовков (*необязательно*)
+    """
+
+    def post_init(self):
+        super().post_init()
+        rx_v4 = r"\b(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b"
+        rx_v6 = r"\b(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\b"
+        self.regex_v4 = re.compile(self.config.get("regex_v4", rx_v4))
+        self.regex_v6 = re.compile(self.config.get("regex_v6", rx_v6))
+
+    def filter_ipv4(self, ipv4):
+        match = self.regex_v4.search(ipv4 or "")
+        ipv4 = match and match[0]
+        return super().filter_ipv4(ipv4)
+
+    def filter_ipv6(self, ipv6):
+        match = self.regex_v6.search(ipv6 or "")
+        ipv6 = match and match[0]
+        return super().filter_ipv6(ipv6)

settings/config.toml

@@ -1,4 +1,4 @@
-debug = true
+debug = false
 require_ipv4 = true
 
 [sources]
@@ -8,6 +8,10 @@ require_ipv4 = true
     provider = "WTFIsMyIP"
   [sources.ipsb]
     provider = "IPSB"
+  [sources.checkip_dyndns]
+    provider = "GenericHttpRegexSource"
+    url_v4 = "http://checkip.dyndns.org/"
+    #regex_v4 = "\\b\\d{1,3}(\\.\\d{1,3}){3}\\b"
   [sources.ifconfig]
     provider = "GenericHttpSource"
     url_v4 = "https://ifconfig.me/ip"