wip2

При значении 0 количество итераций будет бесконечным

.gitea/workflows/release-tag.yml

@@ -1,28 +0,0 @@
-name: release
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        name: Checkout
-        with:
-          fetch-depth: 0
-      - name: Setup go
-        uses: https://github.com/actions/setup-go@v4
-        with:
-          go-version: '>=1.23.6'
-      - name: Compile
-        run: make release
-      - name: Make release
-        id: use-go-action
-        uses: https://gitea.com/actions/release-action@main
-        with:
-          files: |-
-            bin/*.zip
-          api_key: '${{secrets.RELEASE_TOKEN}}'

.gitea/workflows/release.yml

@@ -0,0 +1,65 @@
+# https://docs.gitea.com/usage/actions/overview
+# https://docs.github.com/ru/actions/reference/workflows-and-actions/contexts
+
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with: # https://github.com/actions/checkout
+          fetch-depth: 0
+
+      - name: Set up go
+        uses: actions/setup-go@v4
+        with: # https://github.com/actions/setup-go
+          go-version: '>=1.24.2'
+
+      - name: Build release files (amd64)
+        run: make release ARCH=amd64
+
+      - name: Build release files (arm64)
+        run: make release ARCH=arm64
+
+      - name: Create new release
+        id: use-go-action
+        uses: https://gitea.com/actions/gitea-release-action@main
+        with: # https://gitea.com/actions/gitea-release-action
+          server_url: https://git.axenov.dev
+          token: '${{secrets.RELEASE_TOKEN}}'
+          files: |-
+            bin/*.zip
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with: # https://github.com/docker/setup-buildx-action
+          build-args: "IPTVC_VERSION=${{ github.ref_name }}"
+          buildkitd-config-inline: |
+            # https://github.com/moby/buildkit/blob/master/docs/buildkitd.toml.md
+            [ registry."docker.io" ]
+            mirrors = ["https://dockerhub.timeweb.cloud", "https://dh-mirror.gitverse.ru"]
+            http = true
+            insecure = true
+
+      - name: Log in to Gitea Container Registry
+        uses: docker/login-action@v3
+        with: # https://github.com/docker/login-action
+          registry: git.axenov.dev
+          username: ${{ secrets.USERNAME }}
+          password: ${{ secrets.RELEASE_TOKEN }}
+
+      - name: Build and push Docker images
+        uses: docker/build-push-action@v5
+        with: # https://github.com/docker/build-push-action
+          context: .
+          push: true
+          tags: |
+            git.axenov.dev/iptv/iptvc:${{ github.ref_name }}
+            git.axenov.dev/iptv/iptvc:latest

.gitignore

@@ -12,3 +12,4 @@ output/
 iptvc
 
 !/**/*.gitkeep
+.DS_Store

AGENTS.md

@@ -0,0 +1,187 @@
+# Контекст проекта: IPTV Checker (iptvc)
+
+> **Важно:** Этот файл создан автоматически на основе анализа кодовой базы. Используй его как справочный контекст при внесении изменений.
+
+---
+
+## Обзор проекта
+
+**IPTV Checker (iptvc)** — консольная утилита для проверки доступности IPTV-плейлистов и каналов в форматах `m3u` / `m3u8`.
+
+- **Назначение:** Быстрая массовая проверка плейлистов из файлов, по URL или из INI-реестра с расчётом статистики (online/offline).
+- **Экосистема:** Часть проекта [m3u.su](https://m3u.su).
+- **Лицензия:** MIT (см. `LICENSE`).
+- **Автор:** Антон Аксенов.
+
+### Основные технологии
+
+- **Язык:** Go 1.23.6+
+- **CLI-фреймворк:** [spf13/cobra](https://github.com/spf13/cobra)
+- **Кеширование:** [Redis / KeyDB](https://github.com/redis/go-redis) (опционально, через `go-redis/v9`)
+- **Конфигурация окружения:** [godotenv](https://github.com/joho/godotenv) + переменные окружения
+- **Парсинг INI:** [gopkg.in/ini.v1](https://gopkg.in/ini.v1)
+
+### Архитектура
+
+Приложение построено по классической для Go CLI схеме:
+
+```
+cmd/          — команды Cobra (root, check)
+app/          — бизнес-логика и инфраструктура
+  app.go      — инициализация конфигурации, логгера, кеша; глобальные аргументы
+  checker/    — ядро проверки: подготовка списков, HTTP-опрос каналов, семафоры
+  playlist/   — модели Playlist/Channel/Group, парсинг m3u/m3u8
+  inifile/    — чтение реестра плейлистов из INI
+  config/     — чтение конфигурации из env (.env)
+  cache/      — подключение к Redis/KeyDB
+  logger/     — настройка вывода логов
+  tagfile/    — работа с файлом тегов (channels.json)
+  utils/      — вспомогательные функции (MD5, Fetch, ExpandPath и др.)
+main.go       — точка входа: контекст с отменой по сигналу, делегация cmd.ExecuteContext
+```
+
+---
+
+## Сборка и запуск
+
+### Локальная разработка
+
+```bash
+# Быстрый запуск из исходников
+go run .
+
+# Сборка бинаря
+go build -o iptvc .
+
+# Показать справку
+./iptvc help
+
+# Проверить плейлист из файла
+./iptvc check -f mypls.m3u
+
+# Проверить плейлист по ссылке
+./iptvc check -u http://m3u.su/XYZ
+
+# Проверить плейлисты из INI-файла
+./iptvc check -i playlists.ini
+
+# Только JSON-результат, без логов
+./iptvc check -f mypls.m3u -j -q
+```
+
+### Makefile
+
+| Команда | Описание |
+|---------|----------|
+| `make help` | Справка по целям |
+| `make fmt` | `go fmt ./...` |
+| `make vet` | `go vet ./...` |
+| `make tidy` | `go mod tidy && go mod verify` |
+| `make lint` | `fmt` + `vet` + сборка в `/dev/null` |
+| `make clean` | Удаление скомпилированных бинарей и `bin/` |
+| `make linux` | Сборка для Linux (`GOARCH=amd64` по умолчанию) |
+| `make win` | Сборка для Windows |
+| `make darwin` | Сборка для macOS |
+| `make release` | Полный релиз: все ОС × amd64 + arm64, упаковка в zip |
+
+> **Примечание:** Переменная `GOARCH` переопределяется через окружение, например: `make linux GOARCH=arm64`.
+
+### Docker
+
+```bash
+# Ручная сборка образа
+docker build -t iptvc:latest .
+
+# Скрипт сборки и публикации (с версионированием через git-тег)
+./build-docker-image.sh [TAG]
+```
+
+Dockerfile использует многоступенчатую сборку:
+1. `golang:1.25-alpine` — компиляция бинаря (`CGO_ENABLED=0`, `trimpath`, `ldflags`)
+2. `alpine:3.22.2` — финальный минимальный образ с непривилегированным пользователем.
+
+---
+
+## Конфигурация
+
+Приложение читает переменные окружения (файл `.env` опционален).
+
+| Переменная | По умолчанию | Описание |
+|------------|--------------|----------|
+| `CACHE_ENABLED` | `false` | Включить подключение к кешу |
+| `CACHE_HOST` | `localhost` | Хост Redis/KeyDB |
+| `CACHE_PORT` | `6379` | Порт |
+| `CACHE_USERNAME` | — | Пользователь |
+| `CACHE_PASSWORD` | — | Пароль |
+| `CACHE_DB` | `0` | Номер БД |
+| `CACHE_TTL` | `1800` | TTL записей в секундах |
+
+> Файл `.env.example` содержит пример заполнения.
+
+---
+
+## Ключевые файлы и пакеты
+
+| Путь | Назначение |
+|------|------------|
+| `main.go` | Точка входа: `context.WithCancel`, обработка `SIGINT`/`SIGTERM`, вызов `cmd.ExecuteContext` |
+| `cmd/root.go` | Корневая команда Cobra, глобальный флаг `--verbose` |
+| `cmd/check.go` | Команда `check`: флаги (`-f`, `-u`, `-i`, `-c`, `-t`, `-r`, `-j`, `-q`, `--repeat`, `--every`), цикл повторений, вызов `checker` |
+| `app/app.go` | Глобальные объекты `Args`, `Cache`, `Config`; `Init()` и `Shutdown()` |
+| `app/checker/checker.go` | **Ядро:** подготовка списков, скачивание плейлистов, HTTP-опрос каналов с семафором, динамический расчёт `timeout`/`routines`, кеширование результатов |
+| `app/playlist/playlist.go` | Структуры `Playlist`, `Channel`, `Group`; парсинг m3u/m3u8 (атрибуты `#EXTINF`, `#EXTGRP`, заголовок `#EXTM3U`) |
+| `app/config/config.go` | Чтение конфигурации из env с дефолтами |
+| `app/inifile/inifile.go` | Чтение реестра плейлистов в формате INI |
+| `app/cache/cache.go` | Инициализация клиента Redis/KeyDB |
+| `app/tagfile/tagfile.go` | Загрузка и поиск тегов для каналов |
+| `app/utils/utils.go` | Утилиты: `Fetch`, `ExpandPath`, `Md5str`, `ArrayUnique` |
+| `app/utils/utils_test.go` | Тесты утилит |
+| `app/config/config_test.go` | Тесты конфигурации |
+| `app/playlist/playlist_test.go` | Тесты парсера плейлистов |
+| `docs/json.md` | Документация по структуре JSON-вывода |
+| `build-docker-image.sh` | Скрипт сборки и пуша Docker-образа с версией из git |
+| `Dockerfile` | Многоступенчатая сборка контейнера |
+
+---
+
+## Правила разработки
+
+### Стиль кода
+
+- Код оформлен в едином стиле с лидирующими комментариями-заголовками (автор, лицензия, ссылка на репозиторий).
+- Используются экспортируемые имена с подробными комментариями на русском языке (доминирующий язык комментариев).
+- Глобальные переменные приложения (`Args`, `Cache`, `Config`) расположены в `app/app.go`.
+
+### Тестирование
+
+- Модульные тесты присутствуют для пакетов `utils`, `config`, `playlist`.
+- Для запуска: `go test ./...`.
+
+### Линтинг
+
+- В Makefile есть цель `lint`, объединяющая `go fmt`, `go vet` и проверочную сборку.
+- Перед коммитом рекомендуется выполнять `make lint`.
+
+### Работа с зависимостями
+
+- Модули Go (`go.mod` / `go.sum`).
+- Обновление/очистка: `make tidy`.
+
+### Соглашения по логике
+
+- **Динамические параметры проверки:** количество горутин и HTTP-таймаут рассчитываются в `calcParameters(count)` на основе числа каналов. Чем больше каналов — тем больше параллелизм, но таймаут сокращается.
+- **Семафор:** количество одновременных проверок ограничено через буферизированный канал (`chSemaphores`).
+- **User-Agent:** при проверке каналов используется фиксированный заголовок `Mozilla/5.0 WINK/1.31.1 (AndroidTV/9) HlsWinkPlayer`.
+- **TLS:** проверка выполняется с `InsecureSkipVerify: true`.
+- **Кеш:** результаты проверки плейлистов сериализуются в JSON и сохраняются в Redis с TTL.
+
+---
+
+## Коды возврата
+
+| Код | Значение |
+|-----|----------|
+| `0` | Успех |
+| `1` | Общая ошибка |
+| `2` | Команда `check` запущена без параметров `-f`, `-u` и `-c` (и нет INI по умолчанию) |
+| `130` | Прерывание по сигналу (`SIGINT` / `SIGTERM`) |

Dockerfile

@@ -0,0 +1,24 @@
+FROM golang:1.25-alpine AS iptv-img-builder
+ARG GOOS
+ARG GOARCH
+ARG IPTVC_VERSION
+ENV CGO_ENABLED=0
+ENV GOOS=${GOOS:-linux}
+ENV GOARCH=${GOARCH:-amd64}
+COPY go.mod go.sum ./
+RUN go mod download
+COPY . .
+RUN go build \
+    -trimpath \
+    -ldflags="-s -w -X main.version=${IPTVC_VERSION}" \
+    -o /app/iptvc \
+    .
+
+FROM alpine:3.22.2 AS iptv-img-checker
+LABEL org.opencontainers.image.authors="Anthony Axenov <anthonyaxenov@gmail.com>"
+WORKDIR /app
+RUN apk add --no-cache ca-certificates tzdata
+RUN addgroup -S iptvc-user && adduser -S -G iptvc-user -H -s /sbin/nologin iptvc-user
+COPY --from=iptv-img-builder --chown=iptvc-user:iptvc-user /app/iptvc /app/iptvc
+USER iptvc-user
+ENTRYPOINT ["/app/iptvc"]

Makefile

@@ -1,46 +1,62 @@
 .DEFAULT_GOAL=help
 
-BINARY_NAME=iptvc
-ARCH=amd64
-
-LINUX_PATH="bin/linux_${ARCH}"
-WINDOWS_PATH="bin/windows_${ARCH}"
-DARWIN_PATH="bin/darwin_${ARCH}"
-
-LINUX_FILE="${LINUX_PATH}/${BINARY_NAME}"
-WINDOWS_FILE="${WINDOWS_PATH}/${BINARY_NAME}.exe"
-DARWIN_FILE="${DARWIN_PATH}/${BINARY_NAME}"
+BINARY_NAME := iptvc
+GOARCH ?= amd64
 
 ## clean: Remove all compiled binaries
 clean:
 	@go clean
 	@rm -rf bin/
 
-## linux: Build new binaries for linux (x64)
+## linux: Build new binaries for linux
 linux:
-	@rm -rf ${LINUX_PATH}
-	@GOARCH=${ARCH} GOOS=linux go build -o ${LINUX_FILE} . && echo "Compiled: ${LINUX_FILE}"
+	@rm -rf bin/linux_$(GOARCH)
+	@GOARCH=$(GOARCH) GOOS=linux go build -o bin/linux_$(GOARCH)/$(BINARY_NAME) .
+	@zip -j bin/linux_$(GOARCH).zip bin/linux_$(GOARCH)/$(BINARY_NAME)
+	@echo "Compiled: bin/linux_$(GOARCH)/$(BINARY_NAME) ($(GOARCH))"
 
-## win: Build new binaries for windows (x64)
+## win: Build new binaries for windows
 win:
-	@rm -rf ${WINDOWS_PATH}
-	@GOARCH=${ARCH} GOOS=windows go build -o ${WINDOWS_FILE} . && echo "Compiled: ${WINDOWS_FILE}"
+	@rm -rf bin/windows_$(GOARCH)
+	@GOARCH=$(GOARCH) GOOS=windows go build -o bin/windows_$(GOARCH)/$(BINARY_NAME).exe .
+	@zip -j bin/windows_$(GOARCH).zip bin/windows_$(GOARCH)/$(BINARY_NAME).exe
+	@echo "Compiled: bin/windows_$(GOARCH)/$(BINARY_NAME).exe ($(GOARCH))"
 
-## darwin: Build new binaries for darwin (x64)
+## darwin: Build new binaries for darwin
 darwin:
-	@rm -rf ${DARWIN_PATH}
-	@GOARCH=${ARCH} GOOS=darwin go build -o ${DARWIN_FILE} . && echo "Compiled: ${DARWIN_FILE}"
-
-## all: Build new binaries for linux, windows and darwin (x64)
-all: clean linux win darwin
+	@rm -rf bin/darwin_$(GOARCH)
+	@GOARCH=$(GOARCH) GOOS=darwin go build -o bin/darwin_$(GOARCH)/$(BINARY_NAME) .
+	@zip -j bin/darwin_$(GOARCH).zip bin/darwin_$(GOARCH)/$(BINARY_NAME)
+	@echo "Compiled: bin/darwin_$(GOARCH)/$(BINARY_NAME) ($(GOARCH))"
 
 ## release: Build all binaries and zip them
-release: clean darwin linux win
-	@zip -j ${LINUX_PATH}.zip ${LINUX_FILE}
-	@zip -j ${DARWIN_PATH}.zip ${DARWIN_FILE}
-	@zip -j ${WINDOWS_PATH}.zip ${WINDOWS_FILE}
+release: clean
+	@make linux GOARCH=amd64
+	@make linux GOARCH=arm64
+	@make win GOARCH=amd64
+	@make win GOARCH=arm64
+	@make darwin GOARCH=amd64
+	@make darwin GOARCH=arm64
+
+## fmt: Format Go source code
+fmt:
+	@go fmt ./...
+
+## vet: Run go vet
+vet:
+	@go vet ./...
+
+## tidy: Tidy and verify Go modules
+tidy:
+	@go mod tidy
+	@go mod verify
+
+## lint: Run fmt, vet and build as basic linting
+lint: fmt vet
+	@go build -o /dev/null .
+	@echo "Linting complete"
 
 ## help: Show this message and exit
 help: Makefile
-	@echo "Choose a command run:"
-	@sed -n 's/^##//p' $< | column -t -s ':' |  sed -e 's/^/ /'
+	@echo "Available recipes:"
+	@sed -n 's/^## //p' $< | column -t -s ':'

README.md

@@ -5,22 +5,21 @@
 Консольная программа для проверки IPTV-плейлистов в формате m3u или m3u8.
 
 > **Веб-сайт:** [m3u.su](https://m3u.su)  
-> Исходный код: [git.axenov.dev/IPTV/iptvc](https://git.axenov.dev/IPTV/iptvc)  
+> **Документация:** [m3u.su/docs](https://m3u.su/docs)  
+> Исходный код: [git.axenov.dev/IPTV](https://git.axenov.dev/IPTV)  
 > Telegram-канал: [@iptv_aggregator](https://t.me/iptv_aggregator)  
 > Обсуждение: [@iptv_aggregator_chat](https://t.me/iptv_aggregator_chat)  
-> Дополнительные сведения:
-> * [./docs](./docs)
-> * [git.axenov.dev/IPTV/.profile](https://git.axenov.dev/IPTV/.profile)  
+> Бот: [@iptv_aggregator_bot](https://t.me/iptv_aggregator_bot)  
 
 ## Установка
 
 Достаточно скачать и распаковать архив с подходящим исполняемым файлом [со страницы последнего релиза](https://git.axenov.dev/IPTV/iptvc/releases/latest):
 
-| ОС      | Архив                | Платформа |
-|---------|----------------------|-----------|
-| Linux   | `linux_amd64.zip`    | x64       |
-| MacOS   | `darwin_amd64.zip`   | x64       |
-| Windows | `windows_amd64.zip`  | x64       |
+| ОС      | Скачать для `amd64`                                                                               | Скачать для `arm64`                                                                               |
+| ------- | ------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
+| Linux   | [linux_amd64.zip](https://git.axenov.dev/IPTV/iptvc/releases/download/latest/linux_amd64.zip)     | [linux_arm64.zip](https://git.axenov.dev/IPTV/iptvc/releases/download/latest/linux_arm64.zip)     |
+| MacOS   | [darwin_amd64.zip](https://git.axenov.dev/IPTV/iptvc/releases/download/latest/darwin_amd64.zip)   | [darwin_arm64.zip](https://git.axenov.dev/IPTV/iptvc/releases/download/latest/darwin_arm64.zip)   |
+| Windows | [windows_amd64.zip](https://git.axenov.dev/IPTV/iptvc/releases/download/latest/windows_amd64.zip) | [windows_arm64.zip](https://git.axenov.dev/IPTV/iptvc/releases/download/latest/windows_arm64.zip) |
 
 ## Компиляция
 
@@ -29,7 +28,7 @@
 
 1. Склонировать репозиторий
 2. Находясь в корне репозитория, следует выполнить `make` или `make help` для получения справки.
-3. Другой способ -- выполнить `go run .` для быстрого запуска.
+3. Другой способ — выполнить `go run .` для быстрого запуска.
 
 ## Быстрый старт
 
@@ -69,11 +68,11 @@
 
 ### Другие возможности команды `check`
 
-* `--random|-r X` -- проверить X случайных плейлистов из ini-файла
-* `--json|-j` -- вывести результаты проверки в формате JSON
-* `--quiet|-q` -- полностью подавить вывод лога (включая отладочную информацию)
-* `--verbose|-v` -- добавить в лог более подробную отладочную информацию (значительно увеличит количество строк!)
-* `--tags|-t` -- файл с перечислением тегов (подробности см. [здесь](https://git.axenov.dev/IPTV/playlists#файл-channelsjson))
+* `--random|-r X` — проверить X случайных плейлистов из ini-файла
+* `--json|-j` — вывести результаты проверки в формате JSON
+* `--quiet|-q` — полностью подавить вывод лога (включая отладочную информацию)
+* `--verbose|-v` — добавить в лог более подробную отладочную информацию (значительно увеличит количество строк!)
+* `--tags|-t` — файл с перечислением тегов (подробности см. [здесь](https://git.axenov.dev/IPTV/playlists#файл-channelsjson))
 
 Например, можно получить только json с результатами, передать его в `jq` и, отфильтровав результат, вывести названия оффлайн каналов:
 
@@ -126,8 +125,8 @@ pls='https://example.com/list2.m3u'
 ### Параметры проверки
 
 Выше в п.7 видно некоторые служебные данные:
-* `timeout` -- таймаут каждого запроса в секундах (макс. время ожидания ответа канала);
-* `routines` -- количество одновременных проверок.
+* `timeout` — таймаут каждого запроса в секундах (макс. время ожидания ответа канала);
+* `routines` — количество одновременных проверок.
 
 Эти параметры рассчитываются динамически для каждого плейлиста в отдельности, исходя из количества каналов в каждом (`count`).
 См. [app/checker/checker.go](app/checker/checker.go) для подробностей.
@@ -151,9 +150,9 @@ pls='https://example.com/list2.m3u'
 
 ### Коды возврата
 
-* 0 -- успех
-* 1 -- общая ошибка, см. вывод
-* 2 -- команде `check` не переданы параметры `--file`, `--url` и `--code`
+* 0 — успех
+* 1 — общая ошибка, см. вывод
+* 2 — команде `check` не переданы параметры `--file`, `--url` и `--code`
 
 ## Лицензия
 

app/app.go

@@ -10,20 +10,23 @@ import (
 	"axenov/iptv-checker/app/cache"
 	"axenov/iptv-checker/app/config"
 	"axenov/iptv-checker/app/logger"
+	"log"
 
 	"github.com/redis/go-redis/v9"
 )
 
-const VERSION = "1.0.5"
+var version = "dev"
 
 // Arguments описывает аргументы командной строки
 type Arguments struct {
-	IniPath     string
-	TagsPath    string
-	RandomCount uint
-	NeedJson    bool
-	NeedQuiet   bool
-	Verbose     bool
+	IniPath        string
+	TagsPath       string
+	RandomCount    uint
+	RepeatCount    uint
+	RepeatEverySec uint
+	NeedJson       bool
+	NeedQuiet      bool
+	Verbose        bool
 }
 
 var (
@@ -32,6 +35,18 @@ var (
 	Config *config.Config
 )
 
+// SetVersion устанавливает версию приложения
+func SetVersion(v string) {
+	if v != "" {
+		version = v
+	}
+}
+
+// Version возвращает версию приложения
+func Version() string {
+	return version
+}
+
 // Init инициализирует конфигурацию и подключение к keydb
 func Init() {
 	Config = config.Init()
@@ -40,3 +55,12 @@ func Init() {
 		Cache = cache.Init(&Config.Cache)
 	}
 }
+
+// Shutdown корректно завершает работу приложения
+func Shutdown() {
+	if Cache != nil {
+		if err := Cache.Close(); err != nil {
+			log.Printf("Error closing cache connection: %s", err)
+		}
+	}
+}

app/checker/checker.go

@@ -28,13 +28,20 @@ import (
 	"time"
 )
 
-var (
+// Checker выполняет проверку плейлистов и каналов.
+type Checker struct {
 	tagBlocks []tagfile.TagBlock
-	ctx       = context.Background()
-)
+}
+
+// NewChecker создаёт новый экземпляр Checker.
+func NewChecker(tagsPath string) *Checker {
+	return &Checker{
+		tagBlocks: tagfile.Init(tagsPath),
+	}
+}
 
 // PrepareListsToCheck готовит список плейлистов для проверки
-func PrepareListsToCheck(files []string, urls []string, codes []string) []playlist.Playlist {
+func (c *Checker) PrepareListsToCheck(files []string, urls []string, codes []string) []playlist.Playlist {
 	var lists []playlist.Playlist
 
 	if len(files) > 0 {
@@ -51,7 +58,11 @@ func PrepareListsToCheck(files []string, urls []string, codes []string) []playli
 
 	if len(urls) > 0 {
 		for _, url := range urls {
-			pls, _ := playlist.MakeFromUrl(url)
+			pls, err := playlist.MakeFromUrl(url)
+			if err != nil {
+				log.Printf("Warning: %s, skipping\n", err)
+				continue
+			}
 			lists = append(lists, pls)
 		}
 	}
@@ -74,7 +85,7 @@ func PrepareListsToCheck(files []string, urls []string, codes []string) []playli
 			}
 		} else {
 			if app.Config.Cache.IsActive {
-				cachedLists := getCachedPlaylists()
+				cachedLists := c.getCachedPlaylists()
 				for key := range ini.Lists {
 					if _, ok := cachedLists[key]; ok {
 						continue
@@ -97,20 +108,30 @@ func PrepareListsToCheck(files []string, urls []string, codes []string) []playli
 }
 
 // getCachedPlaylists возвращает из кеша проверенные ранее плейлисты
-func getCachedPlaylists() map[string]playlist.Playlist {
+func (c *Checker) getCachedPlaylists() map[string]playlist.Playlist {
 	result := make(map[string]playlist.Playlist)
-	keys := app.Cache.Keys(ctx, "*")
-	for _, key := range keys.Val() {
-		value := app.Cache.Get(ctx, key).Val()
+	ctx := context.Background()
+	iter := app.Cache.Scan(ctx, 0, "*", 100).Iterator()
+	for iter.Next(ctx) {
+		key := iter.Val()
+		value, err := app.Cache.Get(ctx, key).Result()
+		if err != nil {
+			continue
+		}
 		var pls playlist.Playlist
-		_ = json.Unmarshal([]byte(value), &pls)
+		if err := json.Unmarshal([]byte(value), &pls); err != nil {
+			continue
+		}
 		result[pls.Code] = pls
 	}
+	if err := iter.Err(); err != nil {
+		log.Printf("Error scanning cache: %s", err)
+	}
 	return result
 }
 
 // CheckPlaylists проверяет плейлисты и возвращает их же с результатами проверки
-func CheckPlaylists(lists []playlist.Playlist) (int, int) {
+func (c *Checker) CheckPlaylists(ctx context.Context, lists []playlist.Playlist) (int, int) {
 	count := len(lists)
 	if count == 0 {
 		log.Println("There are no playlists to check")
@@ -119,7 +140,6 @@ func CheckPlaylists(lists []playlist.Playlist) (int, int) {
 
 	log.Printf("%d playlists will be checked\n", len(lists))
 	step, onlineCount, offlineCount := 0, 0, 0
-	tagBlocks = tagfile.Init(app.Args.TagsPath)
 
 	for idx := range lists {
 		pls := lists[idx]
@@ -146,7 +166,7 @@ func CheckPlaylists(lists []playlist.Playlist) (int, int) {
 		if err != nil {
 			log.Printf("Cannot read playlist [%s]: %s\n", pls.Url, err)
 			offlineCount++
-			cachePlaylist(pls)
+			c.cachePlaylist(pls)
 			continue
 		}
 
@@ -156,15 +176,15 @@ func CheckPlaylists(lists []playlist.Playlist) (int, int) {
 		pls = pls.Parse()
 
 		log.Printf("Parsed, checking channels (%d)...\n", len(pls.Channels))
-		pls = CheckChannels(pls)
+		pls = c.CheckChannels(ctx, pls)
 		lists[idx] = pls
-		cachePlaylist(pls)
+		c.cachePlaylist(pls)
 	}
 
 	return onlineCount, offlineCount
 }
 
-func cachePlaylist(pls playlist.Playlist) {
+func (c *Checker) cachePlaylist(pls playlist.Playlist) {
 	if !app.Config.Cache.IsActive {
 		return
 	}
@@ -172,19 +192,27 @@ func cachePlaylist(pls playlist.Playlist) {
 	jsonBytes, err := json.Marshal(pls)
 	if err != nil {
 		log.Printf("Error while saving playlist to cache: %s", err)
+		return
 	}
 
+	key := pls.Code
+	if key == "" {
+		key = "raw:" + utils.Md5str(pls.Url)
+	}
+
+	ctx := context.Background()
 	ttl := time.Duration(app.Config.Cache.Ttl) * time.Second
-	written := app.Cache.Set(ctx, pls.Code, string(jsonBytes), ttl)
+	written := app.Cache.Set(ctx, key, string(jsonBytes), ttl)
 	if written.Err() != nil {
-		log.Printf("Error while saving playlist to cache: %s", err)
+		log.Printf("Error while saving playlist to cache: %s", written.Err())
+		return
 	}
 
 	log.Println("Cached sucessfully")
 }
 
 // CheckChannels проверяет каналы и возвращает их же с результатами проверки
-func CheckChannels(pls playlist.Playlist) playlist.Playlist {
+func (c *Checker) CheckChannels(ctx context.Context, pls playlist.Playlist) playlist.Playlist {
 	type errorData struct {
 		tvChannel playlist.Channel
 		err       error
@@ -196,8 +224,17 @@ func CheckChannels(pls playlist.Playlist) playlist.Playlist {
 		return pls
 	}
 
+	pls.OnlineCount = 0
+	pls.OfflineCount = 0
+
 	timeout, routines := calcParameters(count)
-	httpClient := http.Client{Timeout: timeout}
+	tr := &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+	}
+	httpClient := http.Client{
+		Timeout:   timeout,
+		Transport: tr,
+	}
 	chSemaphores := make(chan struct{}, routines)
 	chOnline := make(chan playlist.Channel, len(pls.Channels))
 	chOffline := make(chan playlist.Channel, len(pls.Channels))
@@ -208,16 +245,18 @@ func CheckChannels(pls playlist.Playlist) playlist.Playlist {
 	for _, tvChannel := range pls.Channels {
 		wg.Add(1)
 		go func(tvChannel playlist.Channel) {
-			chSemaphores <- struct{}{}
 			defer func() {
+				if r := recover(); r != nil {
+					log.Printf("Panic while checking channel '%s': %v", tvChannel.Title, r)
+				}
 				<-chSemaphores
 				wg.Done()
 			}()
+			chSemaphores <- struct{}{}
 
-			tvChannel.Tags = getTagsForChannel(tvChannel)
+			tvChannel.Tags = c.getTagsForChannel(tvChannel)
 
-			http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
-			req, err := http.NewRequest("GET", tvChannel.URL, nil)
+			req, err := http.NewRequestWithContext(ctx, "GET", tvChannel.URL, nil)
 			if err != nil {
 				data := errorData{tvChannel: tvChannel, err: err}
 				chError <- data
@@ -238,7 +277,13 @@ func CheckChannels(pls playlist.Playlist) playlist.Playlist {
 			tvChannel.IsOnline = tvChannel.Status < http.StatusBadRequest
 			tvChannel.ContentType = resp.Header.Get("Content-Type")
 			chunk := io.LimitReader(resp.Body, 512) // just for sure
-			bodyBytes, _ := io.ReadAll(chunk)
+			bodyBytes, err := io.ReadAll(chunk)
+			if err != nil {
+				_ = resp.Body.Close()
+				data := errorData{tvChannel: tvChannel, err: err}
+				chError <- data
+				return
+			}
 			bodyString := string(bodyBytes)
 			_ = resp.Body.Close()
 			contentType := http.DetectContentType(bodyBytes)
@@ -322,6 +367,10 @@ func CheckChannels(pls playlist.Playlist) playlist.Playlist {
 
 // calcParameters вычисляет оптимальное количество горутин и таймаут запроса
 func calcParameters(count int) (time.Duration, int) {
+	if count <= 0 {
+		return 10 * time.Second, 1
+	}
+
 	routines := count
 	if routines > 3000 {
 		routines = 3000
@@ -357,10 +406,10 @@ func calcParameters(count int) (time.Duration, int) {
 }
 
 // getTagsForChannel ищет и возвращает теги для канала
-func getTagsForChannel(tvChannel playlist.Channel) []string {
+func (c *Checker) getTagsForChannel(tvChannel playlist.Channel) []string {
 	var foundTags []string
 
-	for _, block := range tagBlocks {
+	for _, block := range c.tagBlocks {
 		tags := block.GetTags(tvChannel)
 		if tags != nil {
 			foundTags = append(foundTags, tags...)

app/config/config.go

@@ -7,15 +7,15 @@
 package config
 
 import (
-	"github.com/joho/godotenv"
 	"os"
 	"strconv"
+
+	"github.com/joho/godotenv"
 )
 
 // Config описывает конфигурацию
 type Config struct {
-	DebugMode bool
-	Cache     CacheConfig
+	Cache CacheConfig
 }
 
 // CacheConfig описывает конфигурацию подключения к keydb
@@ -34,7 +34,6 @@ type CacheConfig struct {
 func Init() *Config {
 	_ = godotenv.Load(".env")
 	return &Config{
-		//DebugMode: readEnvBoolean("APP_DEBUG", false),
 		Cache: CacheConfig{
 			IsEnabled: readEnvBoolean("CACHE_ENABLED", false),
 			Host:      readEnv("CACHE_HOST", "localhost"),

app/config/config_test.go

@@ -0,0 +1,49 @@
+package config
+
+import (
+	"os"
+	"testing"
+)
+
+func TestReadEnv(t *testing.T) {
+	_ = os.Setenv("TEST_VAR_IPTVC", "value123")
+	defer os.Unsetenv("TEST_VAR_IPTVC")
+
+	got := readEnv("TEST_VAR_IPTVC", "default")
+	if got != "value123" {
+		t.Errorf("readEnv = %q, want %q", got, "value123")
+	}
+
+	gotDefault := readEnv("TEST_VAR_MISSING", "default")
+	if gotDefault != "default" {
+		t.Errorf("readEnv default = %q, want %q", gotDefault, "default")
+	}
+}
+
+func TestReadEnvBoolean(t *testing.T) {
+	_ = os.Setenv("TEST_BOOL", "true")
+	defer os.Unsetenv("TEST_BOOL")
+
+	if !readEnvBoolean("TEST_BOOL", false) {
+		t.Error("readEnvBoolean(true) returned false")
+	}
+
+	if readEnvBoolean("TEST_BOOL_MISSING", false) {
+		t.Error("readEnvBoolean(missing, false) returned true")
+	}
+}
+
+func TestReadEnvInteger(t *testing.T) {
+	_ = os.Setenv("TEST_INT", "42")
+	defer os.Unsetenv("TEST_INT")
+
+	got := readEnvInteger("TEST_INT", 0)
+	if got != 42 {
+		t.Errorf("readEnvInteger = %d, want 42", got)
+	}
+
+	gotDefault := readEnvInteger("TEST_INT_MISSING", 10)
+	if gotDefault != 10 {
+		t.Errorf("readEnvInteger default = %d, want 10", gotDefault)
+	}
+}

app/logger/logger.go

@@ -9,7 +9,6 @@ package logger
 import (
 	"io"
 	"log"
-	"log/slog"
 	"os"
 )
 
@@ -20,22 +19,3 @@ func Init(quiet bool) {
 		log.SetOutput(io.Discard)
 	}
 }
-
-// InitSlog инициализирует продвинутый логгер
-// TODO пока непонятно что с этим делать
-func InitSlog(quiet bool, debug bool) {
-	writer := os.Stdout
-	if quiet {
-		writer = nil
-	}
-
-	level := slog.LevelInfo
-	if debug {
-		level = slog.LevelDebug
-	}
-
-	options := slog.HandlerOptions{Level: level, AddSource: false}
-	handler := slog.NewTextHandler(writer, &options)
-	logger := slog.New(handler)
-	slog.SetDefault(logger)
-}

app/playlist/playlist.go

@@ -54,8 +54,10 @@ type Playlist struct {
 	CheckedAt    int64              `json:"checkedAt"`    // Время проверки в формате UNIX timestamp
 }
 
-// tmpChannel хранит временные данные о канале, который обрабатывается в Parse
-var tmpChannel = Channel{}
+var (
+	attrRegex  = regexp.MustCompile(`(?U)([a-z-]+)="(.*)"`)
+	titleRegex = regexp.MustCompile(`['"]?\s*,\s*(.+)`)
+)
 
 // MakeFromFile создаёт экземпляр плейлиста из файла
 func MakeFromFile(filepath string) (Playlist, error) {
@@ -98,25 +100,34 @@ func MakeFromUrl(url string) (Playlist, error) {
 // parseAttributes парсит атрибуты тегов #EXT*
 func parseAttributes(line string) map[string]string {
 	result := make(map[string]string)
-	regex := regexp.MustCompile(`(?U)([a-z-]+)="(.*)"`)
-	regexMatches := regex.FindAllStringSubmatch(line, -1)
+	regexMatches := attrRegex.FindAllStringSubmatch(line, -1)
 	for _, match := range regexMatches {
 		result[match[1]] = match[2]
 	}
 	return result
 }
 
-// parseName парсит название канала из строки тега #EXTINF
-func parseName(line string) string {
-	//TODO https://git.axenov.dev/IPTV/iptvc/issues/7
-	parts := strings.Split(line, ",")
-	if len(parts) == 2 {
-		return strings.Trim(parts[1], " ")
+// parseTitle парсит название канала из строки тега #EXTINF
+func parseTitle(line string) string {
+	// сначала пытаемся по-доброму: в строке есть тег, могут быть атрибуты,
+	// есть запятая-разделитель, после неё -- название канала (с запятыми или без)
+	regexMatches := titleRegex.FindAllStringSubmatch(line, -1)
+	if len(regexMatches) > 0 && len(regexMatches[0]) >= 2 {
+		return strings.TrimSpace(regexMatches[0][1])
 	}
 
-	regex := regexp.MustCompile(`['"]?\s*,\s*(.+)`)
-	regexMatches := regex.FindAllStringSubmatch(line, -1)
-	return regexMatches[0][1]
+	// теперь пытаемся хоть как-то: в строке есть тег, могут быть атрибуты,
+	// НЕТ запятой-разделителя и название канала (с запятыми или без)
+	lastQuotePos := strings.LastIndexAny(line, `,"'`)
+	if lastQuotePos != -1 && lastQuotePos < len(line)-1 {
+		afterLastQuote := line[lastQuotePos+1:]
+		name := strings.TrimSpace(afterLastQuote)
+		if name != "" {
+			return name
+		}
+	}
+
+	return line // ну штош
 }
 
 // Download загружает плейлист по URL-адресу
@@ -148,6 +159,7 @@ func (pls *Playlist) ReadFromFs() error {
 // Parse разбирает плейлист
 func (pls *Playlist) Parse() Playlist {
 	isChannel := false
+	tmpChannel := Channel{}
 	pls.Attributes = make(map[string]string)
 	pls.Channels = make(map[string]Channel)
 	pls.Groups = make(map[string]Group)
@@ -170,7 +182,7 @@ func (pls *Playlist) Parse() Playlist {
 		if strings.HasPrefix(line, "#EXTINF") {
 			isChannel = true
 			tmpChannel.Attributes = parseAttributes(line)
-			tmpChannel.Title = parseName(line)
+			tmpChannel.Title = parseTitle(line)
 
 			if tmpChannel.Title == "" {
 				if tvgid, ok := tmpChannel.Attributes["tvg-id"]; ok {

app/playlist/playlist_test.go

@@ -0,0 +1,63 @@
+package playlist
+
+import (
+	"testing"
+)
+
+func TestParseAttributes(t *testing.T) {
+	line := `#EXTINF:-1 tvg-id="test" group-title="News",Channel Name`
+	attrs := parseAttributes(line)
+	if attrs["tvg-id"] != "test" {
+		t.Errorf("tvg-id = %q, want %q", attrs["tvg-id"], "test")
+	}
+	if attrs["group-title"] != "News" {
+		t.Errorf("group-title = %q, want %q", attrs["group-title"], "News")
+	}
+}
+
+func TestParseTitle(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{`#EXTINF:-1,Channel Name`, "Channel Name"},
+		{`#EXTINF:-1 tvg-id="x",Another Channel`, "Another Channel"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.expected, func(t *testing.T) {
+			got := parseTitle(tt.input)
+			if got != tt.expected {
+				t.Errorf("parseTitle(%q) = %q, want %q", tt.input, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestPlaylistParse(t *testing.T) {
+	content := `#EXTM3U
+#EXTINF:-1 tvg-id="1" group-title="News",First Channel
+http://example.com/1
+#EXTINF:-1 tvg-id="2",Second Channel
+http://example.com/2
+`
+	pls := Playlist{Content: content}
+	result := pls.Parse()
+
+	if len(result.Channels) != 2 {
+		t.Errorf("channels count = %d, want 2", len(result.Channels))
+	}
+
+	if len(result.Groups) != 1 {
+		t.Errorf("groups count = %d, want 1", len(result.Groups))
+	}
+
+	for _, ch := range result.Channels {
+		if ch.URL == "" {
+			t.Error("channel URL is empty")
+		}
+		if ch.Title == "" {
+			t.Error("channel Title is empty")
+		}
+	}
+}

app/tagfile/tagfile.go

@@ -75,8 +75,12 @@ func (block *TagBlock) GetTags(ch playlist.Channel) []string {
 
 // Init инициализирует объекты тегов из тегфайла
 func Init(path string) []TagBlock {
-	pathNormalized, _ := utils.ExpandPath(path)
-	_, err := os.Stat(pathNormalized)
+	pathNormalized, err := utils.ExpandPath(path)
+	if err != nil {
+		log.Println("Warning: all channels will be untagged due to error:", err)
+		return nil
+	}
+	_, err = os.Stat(pathNormalized)
 	if err != nil {
 		log.Println("Warning: all channels will be untagged due to error:", err)
 		return nil

app/utils/utils.go

@@ -52,8 +52,13 @@ func Fetch(url string) ([]byte, error) {
 	}
 
 	req.Header.Set("User-Agent", "Mozilla/5.0 WINK/1.31.1 (AndroidTV/9) HlsWinkPlayer")
-	http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
-	httpClient := http.Client{Timeout: 10 * time.Second}
+	transport := &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+	}
+	httpClient := http.Client{
+		Timeout:   10 * time.Second,
+		Transport: transport,
+	}
 	resp, err := httpClient.Do(req)
 	if err != nil {
 		return nil, err

app/utils/utils_test.go

@@ -0,0 +1,51 @@
+package utils
+
+import (
+	"testing"
+)
+
+func TestMd5str(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"hello", "5d41402abc4b2a76b9719d911017c592"},
+		{"", "d41d8cd98f00b204e9800998ecf8427e"},
+		{"http://example.com/stream", "a1b2c3d4e5f6"}, // just length check
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			got := Md5str(tt.input)
+			if len(got) != 32 {
+				t.Errorf("Md5str(%q) length = %d, want 32", tt.input, len(got))
+			}
+		})
+	}
+}
+
+func TestArrayUnique(t *testing.T) {
+	input := []string{"a", "b", "a", "c", "b"}
+	expected := []string{"a", "b", "c"}
+	got := ArrayUnique(input)
+	if len(got) != len(expected) {
+		t.Errorf("ArrayUnique length = %d, want %d", len(got), len(expected))
+	}
+	seen := make(map[string]bool)
+	for _, v := range got {
+		if seen[v] {
+			t.Errorf("ArrayUnique returned duplicate: %s", v)
+		}
+		seen[v] = true
+	}
+}
+
+func TestExpandPath(t *testing.T) {
+	got, err := ExpandPath("/tmp/test.txt")
+	if err != nil {
+		t.Fatalf("ExpandPath error: %v", err)
+	}
+	if got == "" {
+		t.Error("ExpandPath returned empty string")
+	}
+}

build-docker-image.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+[[ "$1" ]] && DOCKER_TAG="$1" || DOCKER_TAG="latest"
+[[ "$1" ]] && GIT_TAG="$1" || GIT_TAG=$(git describe --tags --always)
+GIT_HASH=$(git rev-parse --short HEAD)
+IPTVC_VERSION="${GIT_TAG}-${GIT_HASH}"
+
+git checkout "${GIT_TAG}" 2>/dev/null
+docker build \
+    --build-arg IPTVC_VERSION="${IPTVC_VERSION}" \
+    --build-arg GOOS="${GOOS:-linux}" \
+    --build-arg GOARCH="${GOARCH:-amd64}" \
+    --tag iptvc:"${DOCKER_TAG}" \
+    --tag git.axenov.dev/iptv/iptvc:"${DOCKER_TAG}" \
+    .
+
+docker push git.axenov.dev/iptv/iptvc:"${DOCKER_TAG}"

cmd/check.go

@@ -27,22 +27,59 @@ var checkCmd = &cobra.Command{
 		files, _ := cmd.Flags().GetStringSlice("file")
 		urls, _ := cmd.Flags().GetStringSlice("url")
 		codes, _ := cmd.Flags().GetStringSlice("code")
-		lists := checker.PrepareListsToCheck(files, urls, codes)
 
-		startTime := time.Now()
-		onlineCount, offlineCount := checker.CheckPlaylists(lists)
+		waitSeconds := app.Args.RepeatEverySec
+		if waitSeconds <= 0 {
+			waitSeconds = 5
+		}
 
-		log.Printf(
-			"Done! count=%d online=%d offline=%d elapsedTime=%.2fs\n",
-			len(lists),
-			onlineCount,
-			offlineCount,
-			time.Since(startTime).Seconds(),
-		)
+		currentIteration := 1
+		for {
+			if app.Args.RepeatCount != 1 {
+				log.Printf(
+					"@ New iteration current=%d count=%d\n",
+					currentIteration,
+					app.Args.RepeatCount,
+				)
+			}
 
-		if app.Args.NeedJson {
-			marshal, _ := json.Marshal(lists)
-			fmt.Println(string(marshal))
+			ch := checker.NewChecker(app.Args.TagsPath)
+
+			lists := ch.PrepareListsToCheck(files, urls, codes)
+
+			if len(lists) > 0 {
+				startTime := time.Now()
+				ctx := cmd.Context()
+				onlineCount, offlineCount := ch.CheckPlaylists(ctx, lists)
+
+				log.Printf(
+					"Done! count=%d online=%d offline=%d elapsedTime=%.2fs\n",
+					len(lists),
+					onlineCount,
+					offlineCount,
+					time.Since(startTime).Seconds(),
+				)
+
+				if app.Args.NeedJson {
+					marshal, err := json.Marshal(lists)
+					if err != nil {
+						log.Printf("Error marshaling results: %s", err)
+					} else {
+						fmt.Println(string(marshal))
+					}
+				}
+			} else {
+				log.Println("There are no playlists to check")
+			}
+
+			if app.Args.RepeatCount != 0 {
+				if uint(currentIteration) == app.Args.RepeatCount {
+					break
+				}
+				currentIteration++
+			}
+			log.Printf("Waiting for new iteration... seconds=%d\n", app.Args.RepeatEverySec)
+			time.Sleep(time.Duration(app.Args.RepeatEverySec) * time.Second)
 		}
 	},
 }
@@ -51,6 +88,8 @@ func init() {
 	checkCmd.Flags().StringVarP(&app.Args.TagsPath, "tags", "t", "./channels.json", "path to a local tagfile")
 	checkCmd.Flags().StringVarP(&app.Args.IniPath, "ini", "i", "./playlists.ini", "path to a local ini-file")
 	checkCmd.Flags().UintVarP(&app.Args.RandomCount, "random", "r", 0, "take this count of random playlists to check from ini-file")
+	checkCmd.Flags().UintVarP(&app.Args.RepeatCount, "repeat", "", 1, "repeat same check X times")
+	checkCmd.Flags().UintVarP(&app.Args.RepeatEverySec, "every", "", 5, "wait N seconds after every check")
 	checkCmd.Flags().BoolVarP(&app.Args.NeedJson, "json", "j", false, "print results in JSON format in the end")
 	checkCmd.Flags().BoolVarP(&app.Args.NeedQuiet, "quiet", "q", false, "suppress logs (does not affect on -j)")
 	checkCmd.Flags().StringSliceP("file", "f", []string{}, "path to a local playlist file (m3u/m3u8)")

cmd/root.go

@@ -8,6 +8,7 @@ package cmd
 
 import (
 	"axenov/iptv-checker/app"
+	"context"
 	"os"
 
 	"github.com/spf13/cobra"
@@ -33,6 +34,11 @@ func Execute() {
 	}
 }
 
+// ExecuteContext runs the root command with the given context.
+func ExecuteContext(ctx context.Context) error {
+	return rootCmd.ExecuteContext(ctx)
+}
+
 func init() {
 	rootCmd.PersistentFlags().BoolVarP(&app.Args.Verbose, "verbose", "v", false, "enable additional output")
 }

cmd/version.go

@@ -18,7 +18,7 @@ var versionCmd = &cobra.Command{
 	Use:   "version",
 	Short: "Show version",
 	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Println("iptvc v" + app.VERSION)
+		fmt.Println("iptvc v" + app.Version())
 	},
 }
 

main.go

@@ -7,9 +7,33 @@
 package main
 
 import (
+	"axenov/iptv-checker/app"
 	"axenov/iptv-checker/cmd"
+	"context"
+	"os"
+	"os/signal"
+	"syscall"
 )
 
+var version string
+
 func main() {
-	cmd.Execute()
+	app.SetVersion(version)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	sigCh := make(chan os.Signal, 1)
+	signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
+	go func() {
+		<-sigCh
+		cancel()
+		app.Shutdown()
+		os.Exit(130)
+	}()
+
+	if err := cmd.ExecuteContext(ctx); err != nil {
+		os.Exit(1)
+	}
+	app.Shutdown()
 }