This commit is contained in:
38
app/app.go
Normal file
38
app/app.go
Normal file
@@ -0,0 +1,38 @@
|
||||
/*
|
||||
* Copyright (c) 2025, Антон Аксенов
|
||||
* This file is part of iptvc project
|
||||
* MIT License: https://git.axenov.dev/IPTV/iptvc/src/branch/master/LICENSE
|
||||
*/
|
||||
|
||||
package app
|
||||
|
||||
import (
|
||||
"axenov/iptv-checker/app/config"
|
||||
"github.com/redis/go-redis/v9"
|
||||
)
|
||||
|
||||
const VERSION = "0.1.0"
|
||||
|
||||
// Arguments описывает аргументы командной строки
|
||||
type Arguments struct {
|
||||
IniPath string
|
||||
TagsPath string
|
||||
RandomCount uint
|
||||
NeedJson bool
|
||||
NeedQuiet bool
|
||||
Verbose bool
|
||||
}
|
||||
|
||||
var (
|
||||
Args Arguments
|
||||
Redis *redis.Client
|
||||
Config *config.Config
|
||||
//TagBlocks []tagfile.TagBlock
|
||||
)
|
||||
|
||||
// Init инициализирует глобальные переменные
|
||||
func Init() {
|
||||
Config = config.Init()
|
||||
//logger.Init(Args.NeedQuiet)
|
||||
//Redis = cache.Init(Config.Redis)
|
||||
}
|
||||
36
app/cache/cache.go
vendored
Normal file
36
app/cache/cache.go
vendored
Normal file
@@ -0,0 +1,36 @@
|
||||
/*
|
||||
* Copyright (c) 2025, Антон Аксенов
|
||||
* This file is part of iptvc project
|
||||
* MIT License: https://git.axenov.dev/IPTV/iptvc/src/branch/master/LICENSE
|
||||
*/
|
||||
|
||||
package cache
|
||||
|
||||
import (
|
||||
"axenov/iptv-checker/app/config"
|
||||
"context"
|
||||
"fmt"
|
||||
"github.com/redis/go-redis/v9"
|
||||
"log"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
func Init(cfg config.RedisConfig) *redis.Client {
|
||||
rdb := redis.NewClient(&redis.Options{
|
||||
Addr: fmt.Sprintf("%s:%s", cfg.Host, strconv.Itoa(int(cfg.Port))),
|
||||
DB: int(cfg.Db),
|
||||
PoolSize: 1000,
|
||||
ReadTimeout: -1,
|
||||
WriteTimeout: -1,
|
||||
})
|
||||
client := rdb.Conn()
|
||||
|
||||
var ctx context.Context
|
||||
if client.Ping(ctx).Err() != nil {
|
||||
log.Println("Error while connecting to Redis", cfg.Host, cfg.Port, cfg.Db)
|
||||
} else {
|
||||
log.Println("Connected to Redis", cfg.Host, cfg.Port, cfg.Db)
|
||||
}
|
||||
|
||||
return rdb
|
||||
}
|
||||
336
app/checker/checker.go
Normal file
336
app/checker/checker.go
Normal file
@@ -0,0 +1,336 @@
|
||||
/*
|
||||
* Copyright (c) 2025, Антон Аксенов
|
||||
* This file is part of iptvc project
|
||||
* MIT License: https://git.axenov.dev/IPTV/iptvc/src/branch/master/LICENSE
|
||||
*/
|
||||
|
||||
package checker
|
||||
|
||||
import (
|
||||
"axenov/iptv-checker/app"
|
||||
"axenov/iptv-checker/app/inifile"
|
||||
"axenov/iptv-checker/app/playlist"
|
||||
"axenov/iptv-checker/app/tagfile"
|
||||
"axenov/iptv-checker/app/utils"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"maps"
|
||||
"math/rand"
|
||||
"net/http"
|
||||
"os"
|
||||
"runtime"
|
||||
"slices"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
var tagBlocks []tagfile.TagBlock
|
||||
|
||||
// PrepareListsToCheck готовит список плейлистов для проверки
|
||||
func PrepareListsToCheck(files []string, urls []string, codes []string) []playlist.Playlist {
|
||||
var lists []playlist.Playlist
|
||||
|
||||
if len(files) > 0 {
|
||||
for _, filepath := range files {
|
||||
pls, err := playlist.MakeFromFile(filepath)
|
||||
if err != nil {
|
||||
log.Printf("Warning: %s, skipping\n", err)
|
||||
continue
|
||||
}
|
||||
|
||||
lists = append(lists, pls)
|
||||
}
|
||||
}
|
||||
|
||||
if len(urls) > 0 {
|
||||
for _, url := range urls {
|
||||
pls, _ := playlist.MakeFromUrl(url)
|
||||
lists = append(lists, pls)
|
||||
}
|
||||
}
|
||||
|
||||
ini, err := inifile.Init(app.Args.IniPath)
|
||||
if err != nil {
|
||||
log.Printf("Warning: %s, all --code flags will be ignored\n", err)
|
||||
return lists
|
||||
}
|
||||
|
||||
if len(codes) > 0 {
|
||||
for _, plsCode := range codes {
|
||||
list := ini.Lists[plsCode]
|
||||
if list.Url == "" {
|
||||
log.Printf("Warning: playlist [%s] not found in ini-file, skipping\n", plsCode)
|
||||
continue
|
||||
}
|
||||
lists = append(lists, list)
|
||||
}
|
||||
} else {
|
||||
lists = slices.Collect(maps.Values(ini.Lists))
|
||||
if int(app.Args.RandomCount) > 0 && int(app.Args.RandomCount) <= len(lists) {
|
||||
rand.Shuffle(len(lists), func(i int, j int) { lists[i], lists[j] = lists[j], lists[i] })
|
||||
lists = lists[:app.Args.RandomCount]
|
||||
}
|
||||
}
|
||||
|
||||
return lists
|
||||
}
|
||||
|
||||
// CheckPlaylists проверяет плейлисты и возвращает их же с результатами проверки
|
||||
func CheckPlaylists(lists []playlist.Playlist) {
|
||||
step := 0
|
||||
count := len(lists)
|
||||
tagBlocks = tagfile.Init(app.Args.TagsPath)
|
||||
|
||||
if count == 0 {
|
||||
log.Println("There are no playlists to check")
|
||||
os.Exit(0)
|
||||
}
|
||||
|
||||
for idx := range lists {
|
||||
pls := lists[idx]
|
||||
step++
|
||||
|
||||
var err error
|
||||
if pls.Source == "-f" {
|
||||
// direct m3u path
|
||||
log.Printf("[%.3d/%.3d] Playlist from filesystem\n", step, count)
|
||||
log.Printf("Reading file... (%s)\n", pls.Url)
|
||||
err = pls.ReadFromFs()
|
||||
} else if pls.Source == "-u" {
|
||||
// direct m3u url
|
||||
log.Printf("[%.3d/%.3d] Playlist [%s]\n", step, count, pls.Url)
|
||||
log.Printf("Fetching... (%s)\n", pls.Url)
|
||||
err = pls.Download()
|
||||
} else {
|
||||
// from ini
|
||||
log.Printf("[%.3d/%.3d] Playlist [%s]\n", step, count, pls.Code)
|
||||
log.Printf("Fetching... (%s)\n", pls.Url)
|
||||
err = pls.Download()
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
log.Printf("Cannot read playlist [%s]: %s", pls.Url, err)
|
||||
continue
|
||||
}
|
||||
|
||||
log.Println("Parsing content...")
|
||||
pls.IsOnline = true
|
||||
pls = pls.Parse()
|
||||
|
||||
log.Printf("Parsed, checking channels (%d)...\n", len(pls.Channels))
|
||||
pls = CheckChannels(pls)
|
||||
|
||||
lists[idx] = pls
|
||||
}
|
||||
|
||||
if app.Args.NeedJson {
|
||||
marshal, _ := json.Marshal(lists)
|
||||
fmt.Println(string(marshal))
|
||||
}
|
||||
}
|
||||
|
||||
// CheckChannels проверяет каналы и возвращает их же с результатами проверки
|
||||
func CheckChannels(pls playlist.Playlist) playlist.Playlist {
|
||||
type errorData struct {
|
||||
tvChannel playlist.Channel
|
||||
err error
|
||||
}
|
||||
|
||||
count := len(pls.Channels)
|
||||
timeout, routines := calcParameters(count)
|
||||
httpClient := http.Client{Timeout: timeout}
|
||||
chSemaphores := make(chan struct{}, routines)
|
||||
chOnline := make(chan playlist.Channel, len(pls.Channels))
|
||||
chOffline := make(chan playlist.Channel, len(pls.Channels))
|
||||
chError := make(chan errorData, len(pls.Channels))
|
||||
var wg sync.WaitGroup
|
||||
|
||||
startTime := time.Now()
|
||||
for _, tvChannel := range pls.Channels {
|
||||
wg.Add(1)
|
||||
go func(tvChannel playlist.Channel) {
|
||||
chSemaphores <- struct{}{}
|
||||
defer func() {
|
||||
<-chSemaphores
|
||||
wg.Done()
|
||||
}()
|
||||
|
||||
tvChannel.Tags = getTagsForChannel(tvChannel)
|
||||
|
||||
req, err := http.NewRequest("GET", tvChannel.URL, nil)
|
||||
tvChannel.CheckedAt = time.Now().Unix()
|
||||
if err != nil {
|
||||
data := errorData{tvChannel: tvChannel, err: err}
|
||||
chError <- data
|
||||
return
|
||||
}
|
||||
|
||||
//TODO user-agent
|
||||
req.Header.Set("User-Agent", "Mozilla/5.0 WINK/1.31.1 (AndroidTV/9) HlsWinkPlayer")
|
||||
resp, err := httpClient.Do(req)
|
||||
if err != nil {
|
||||
data := errorData{tvChannel: tvChannel, err: err}
|
||||
chError <- data
|
||||
return
|
||||
}
|
||||
|
||||
tvChannel.Status = resp.StatusCode
|
||||
tvChannel.IsOnline = tvChannel.Status < http.StatusBadRequest
|
||||
tvChannel.ContentType = resp.Header.Get("Content-Type")
|
||||
bodyBytes, _ := io.ReadAll(resp.Body)
|
||||
bodyString := string(bodyBytes)
|
||||
resp.Body.Close()
|
||||
contentType := http.DetectContentType(bodyBytes)
|
||||
|
||||
isContentBinary := strings.Contains(contentType, "octet-stream") ||
|
||||
strings.Contains(contentType, "video/")
|
||||
|
||||
isContentCorrect := isContentBinary ||
|
||||
strings.Contains(bodyString, "#EXTM3U") ||
|
||||
strings.Contains(bodyString, "<SegmentTemplate")
|
||||
|
||||
if tvChannel.Status >= http.StatusBadRequest || !isContentCorrect {
|
||||
tvChannel.Error = bodyString
|
||||
chOffline <- tvChannel
|
||||
return
|
||||
}
|
||||
|
||||
if isContentBinary {
|
||||
tvChannel.Content = "binary"
|
||||
} else {
|
||||
tvChannel.Content = bodyString
|
||||
}
|
||||
|
||||
chOnline <- tvChannel
|
||||
return
|
||||
}(tvChannel)
|
||||
}
|
||||
|
||||
for idx := 1; idx <= count; idx++ {
|
||||
select {
|
||||
case tvChannel := <-chOnline:
|
||||
tvChannel.IsOnline = true
|
||||
pls.OnlineCount++
|
||||
pls.Channels[tvChannel.Id] = tvChannel
|
||||
if app.Args.Verbose {
|
||||
log.Printf("[%.3d/%.3d] ONLINE '%s'\n", idx, count, tvChannel.Title)
|
||||
log.Printf("> Id: %s\n", tvChannel.Id)
|
||||
log.Printf("> Tags: %s\n", strings.Join(tvChannel.Tags, ","))
|
||||
log.Printf("> MimeType: %s\n", tvChannel.ContentType)
|
||||
}
|
||||
case tvChannel := <-chOffline:
|
||||
pls.OfflineCount++
|
||||
pls.Channels[tvChannel.Id] = tvChannel
|
||||
if app.Args.Verbose {
|
||||
log.Printf("[%.3d/%.3d] OFFLINE '%s'\n", idx, count, tvChannel.Title)
|
||||
log.Printf("> Id: %s\n", tvChannel.Id)
|
||||
log.Printf("> Tags: %s\n", strings.Join(tvChannel.Tags, ","))
|
||||
log.Printf("> Status: %d\n", tvChannel.Status)
|
||||
}
|
||||
case data := <-chError:
|
||||
pls.OfflineCount++
|
||||
pls.Channels[data.tvChannel.Id] = data.tvChannel
|
||||
if app.Args.Verbose {
|
||||
log.Printf("[%.3d/%.3d] ERROR '%s'\n", idx, count, data.tvChannel.Title)
|
||||
log.Printf("> Id: %s\n", data.tvChannel.Id)
|
||||
log.Printf("> Tags: %s\n", strings.Join(data.tvChannel.Tags, ","))
|
||||
log.Printf("> Error: %s\n", data.err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
wg.Wait()
|
||||
close(chOnline)
|
||||
close(chOffline)
|
||||
close(chError)
|
||||
pls.CheckedAt = time.Now().Unix()
|
||||
|
||||
log.Printf(
|
||||
"Checked successfully! online=%d onlinePercent=%.2f%% offline=%d offlinePercent=%.2f%% elapsedTime=%.2fs",
|
||||
pls.OnlineCount,
|
||||
float64(pls.OnlineCount)/float64(len(pls.Channels))*100,
|
||||
pls.OfflineCount,
|
||||
float64(pls.OfflineCount)/float64(len(pls.Channels))*100,
|
||||
time.Since(startTime).Seconds(),
|
||||
)
|
||||
|
||||
return pls
|
||||
}
|
||||
|
||||
// calcParameters вычисляет оптимальное количество горутин и таймаут запроса
|
||||
func calcParameters(count int) (time.Duration, int) {
|
||||
// коэффициент нагрузки
|
||||
var k float32
|
||||
// чем ниже, тем больше горутин, меньше таймаут, быстрее проверка, хуже результаты
|
||||
// чем выше, тем меньше горутин, больше таймаут, медленнее проверка, лучше результаты
|
||||
|
||||
switch true {
|
||||
case count >= 4000:
|
||||
k = 5
|
||||
case count >= 3000:
|
||||
k = 4.5
|
||||
case count >= 2500:
|
||||
k = 4
|
||||
case count >= 2000:
|
||||
k = 3.5
|
||||
case count >= 1500:
|
||||
k = 3
|
||||
case count >= 1000:
|
||||
k = 2.5
|
||||
case count >= 500:
|
||||
k = 2
|
||||
case count >= 100:
|
||||
k = 1.5
|
||||
default:
|
||||
k = 1
|
||||
}
|
||||
|
||||
routines := int(float32(count) / k / float32(runtime.NumCPU()))
|
||||
if routines > 500 {
|
||||
routines = 500
|
||||
}
|
||||
if routines < 1 {
|
||||
routines = 1
|
||||
}
|
||||
|
||||
timeout := 10/k + 2
|
||||
if timeout > 10 {
|
||||
timeout = 10
|
||||
}
|
||||
if timeout < 1 {
|
||||
timeout = 1
|
||||
}
|
||||
|
||||
duration := time.Duration(timeout) * time.Second
|
||||
log.Printf(
|
||||
"Check parameters calculated: count=%d timeout=%.2fs routines=%d\n",
|
||||
count,
|
||||
duration.Seconds(),
|
||||
routines,
|
||||
)
|
||||
|
||||
return duration, routines
|
||||
}
|
||||
|
||||
// getTagsForChannel ищет и возвращает теги для канала
|
||||
func getTagsForChannel(tvChannel playlist.Channel) []string {
|
||||
var foundTags []string
|
||||
|
||||
for _, block := range tagBlocks {
|
||||
tags := block.GetTags(tvChannel)
|
||||
if tags != nil {
|
||||
foundTags = append(foundTags, tags...)
|
||||
}
|
||||
}
|
||||
|
||||
if len(foundTags) == 0 {
|
||||
foundTags = append(foundTags, "untagged")
|
||||
} else if len(foundTags) > 0 {
|
||||
foundTags = utils.ArrayUnique(foundTags)
|
||||
}
|
||||
|
||||
return foundTags
|
||||
}
|
||||
82
app/config/config.go
Normal file
82
app/config/config.go
Normal file
@@ -0,0 +1,82 @@
|
||||
/*
|
||||
* Copyright (c) 2025, Антон Аксенов
|
||||
* This file is part of iptvc project
|
||||
* MIT License: https://git.axenov.dev/IPTV/iptvc/src/branch/master/LICENSE
|
||||
*/
|
||||
|
||||
package config
|
||||
|
||||
import (
|
||||
"os"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
// Config описывает конфигурацию
|
||||
type Config struct {
|
||||
DebugMode bool
|
||||
Redis RedisConfig
|
||||
Http HttpConfig
|
||||
}
|
||||
|
||||
// RedisConfig описывает конфигурацию подключения к Redis
|
||||
type RedisConfig struct {
|
||||
Host string
|
||||
Port uint
|
||||
Username string
|
||||
Password string
|
||||
Db uint
|
||||
}
|
||||
|
||||
// HttpConfig описывает конфигурацию веб-сервера
|
||||
type HttpConfig struct {
|
||||
Host string
|
||||
Port uint
|
||||
}
|
||||
|
||||
// Init инициализирует объект конфигурации из переменных окружения
|
||||
func Init() *Config {
|
||||
return &Config{
|
||||
DebugMode: readEnvBoolean("APP_DEBUG", false),
|
||||
Redis: RedisConfig{
|
||||
Host: readEnv("REDIS_HOST", ""),
|
||||
Port: readEnvInteger("REDIS_PORT", 6379),
|
||||
Username: readEnv("REDIS_USERNAME", ""),
|
||||
Password: readEnv("REDIS_PASSWORD", ""),
|
||||
Db: readEnvInteger("REDIS_DB", 0),
|
||||
},
|
||||
Http: HttpConfig{
|
||||
Host: readEnv("HTTP_HOST", "0.0.0.0"),
|
||||
Port: readEnvInteger("HTTP_PORT", 1380),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// readEnv считывает строковую переменную окружения с заданным именем или возвращает значение по умолчанию
|
||||
func readEnv(key string, defaultValue string) string {
|
||||
value, exists := os.LookupEnv(key)
|
||||
if exists {
|
||||
return value
|
||||
}
|
||||
|
||||
return defaultValue
|
||||
}
|
||||
|
||||
// readEnvBoolean считывает булеву переменную окружения с заданным именем или возвращает значение по умолчанию
|
||||
func readEnvBoolean(name string, defaultValue bool) bool {
|
||||
valStr := readEnv(name, "")
|
||||
val, err := strconv.ParseBool(valStr)
|
||||
if err == nil {
|
||||
return val
|
||||
}
|
||||
return defaultValue
|
||||
}
|
||||
|
||||
// readEnvInteger считывает целочисленную переменную окружения с заданным именем или возвращает значение по умолчанию
|
||||
func readEnvInteger(name string, defaultValue uint) uint {
|
||||
valueStr := readEnv(name, "")
|
||||
value, err := strconv.Atoi(valueStr)
|
||||
if err == nil {
|
||||
return uint(value)
|
||||
}
|
||||
return defaultValue
|
||||
}
|
||||
99
app/inifile/inifile.go
Normal file
99
app/inifile/inifile.go
Normal file
@@ -0,0 +1,99 @@
|
||||
/*
|
||||
* Copyright (c) 2025, Антон Аксенов
|
||||
* This file is part of iptvc project
|
||||
* MIT License: https://git.axenov.dev/IPTV/iptvc/src/branch/master/LICENSE
|
||||
*/
|
||||
|
||||
package inifile
|
||||
|
||||
import (
|
||||
"axenov/iptv-checker/app/playlist"
|
||||
"axenov/iptv-checker/app/utils"
|
||||
"gopkg.in/ini.v1"
|
||||
"log"
|
||||
"os"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// IniFile описывает ini-файл c плейлистами
|
||||
type IniFile struct {
|
||||
File *ini.File
|
||||
Lists map[string]playlist.Playlist
|
||||
}
|
||||
|
||||
// Init загружает данные из ini-файла
|
||||
func Init(path string) (IniFile, error) {
|
||||
ini.DefaultHeader = false
|
||||
|
||||
pathNormalized, err := utils.ExpandPath(path)
|
||||
if err != nil {
|
||||
return IniFile{}, err
|
||||
}
|
||||
|
||||
_, err = os.Stat(pathNormalized)
|
||||
if err != nil {
|
||||
return IniFile{}, err
|
||||
}
|
||||
|
||||
iniFile, err := ini.Load(pathNormalized)
|
||||
if err != nil {
|
||||
return IniFile{}, err
|
||||
}
|
||||
|
||||
lists := make(map[string]playlist.Playlist)
|
||||
|
||||
log.Println("Loading playlists from ini-file:", pathNormalized)
|
||||
for _, section := range iniFile.Sections() {
|
||||
if section.Name() == ini.DefaultSection { //TODO выкосить костыль
|
||||
continue
|
||||
}
|
||||
|
||||
name := getName(section)
|
||||
description := getValue("desc", section)
|
||||
source := getValue("src", section)
|
||||
url := getValue("pls", section)
|
||||
|
||||
if url == "" {
|
||||
log.Printf("Warning: playlist [%s] has incorrect 'pls', skipping", section.Name())
|
||||
continue
|
||||
}
|
||||
|
||||
lists[section.Name()] = playlist.Playlist{
|
||||
Code: section.Name(),
|
||||
Name: name,
|
||||
Description: description,
|
||||
Url: section.KeysHash()["pls"],
|
||||
Source: source,
|
||||
}
|
||||
}
|
||||
log.Printf("Loaded %d playlists\n", len(lists))
|
||||
|
||||
return IniFile{
|
||||
File: iniFile,
|
||||
Lists: lists,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// getValue возвращает значение по ключу в секции
|
||||
func getValue(key string, section *ini.Section) string {
|
||||
if _, ok := section.KeysHash()[key]; !ok {
|
||||
return ""
|
||||
}
|
||||
|
||||
value := strings.Trim(section.KeysHash()[key], "\n\t ")
|
||||
if value == "" {
|
||||
return ""
|
||||
}
|
||||
|
||||
return value
|
||||
}
|
||||
|
||||
// getName возвращает имя плейлиста по секции
|
||||
func getName(section *ini.Section) string {
|
||||
name := getValue("name", section)
|
||||
if name == "" {
|
||||
return "Playlist #" + section.Name()
|
||||
}
|
||||
|
||||
return name
|
||||
}
|
||||
41
app/logger/logger.go
Normal file
41
app/logger/logger.go
Normal file
@@ -0,0 +1,41 @@
|
||||
/*
|
||||
* Copyright (c) 2025, Антон Аксенов
|
||||
* This file is part of iptvc project
|
||||
* MIT License: https://git.axenov.dev/IPTV/iptvc/src/branch/master/LICENSE
|
||||
*/
|
||||
|
||||
package logger
|
||||
|
||||
import (
|
||||
"io"
|
||||
"log"
|
||||
"log/slog"
|
||||
"os"
|
||||
)
|
||||
|
||||
// Init инициализирует стандартный логгер
|
||||
func Init(quiet bool) {
|
||||
log.SetOutput(os.Stdout)
|
||||
if quiet {
|
||||
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)
|
||||
}
|
||||
216
app/playlist/playlist.go
Normal file
216
app/playlist/playlist.go
Normal file
@@ -0,0 +1,216 @@
|
||||
/*
|
||||
* Copyright (c) 2025, Антон Аксенов
|
||||
* This file is part of iptvc project
|
||||
* MIT License: https://git.axenov.dev/IPTV/iptvc/src/branch/master/LICENSE
|
||||
*/
|
||||
|
||||
package playlist
|
||||
|
||||
import (
|
||||
"axenov/iptv-checker/app/utils"
|
||||
"errors"
|
||||
"os"
|
||||
"regexp"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// Group - структура для хранения информации о группе каналов
|
||||
type Group struct {
|
||||
Id string `json:"id"` // Хэш MD5 от названия группы
|
||||
Name string `json:"name"` // Название группы (тег #EXTGRP или атрибут group-title тега #EXTINF)
|
||||
Attributes map[string]string `json:"attributes"` // Атрибуты тега #EXTGRP
|
||||
}
|
||||
|
||||
// Channel - структура для хранения информации о канале и статусе его проверки
|
||||
type Channel struct {
|
||||
Id string `json:"id"` // Хэш MD5 от ссылки на канал
|
||||
Title string `json:"title"` // Название канала
|
||||
URL string `json:"url"` // Ссылка на канал
|
||||
GroupId string `json:"groupId"` // Хэш MD5 от названия группы канала (тег #EXTGRP или атрибут group-title тега #EXTINF)
|
||||
Attributes map[string]string `json:"attributes"` // Атрибуты тега #EXTINF
|
||||
Status int `json:"status"` // Код статуса HTTP
|
||||
IsOnline bool `json:"isOnline"` // Признак доступности канала (при Status < 400)
|
||||
Error string `json:"error"` // Текст ошибки (при Status >= 400)
|
||||
Content string `json:"content"` // Тело ответа (формат m3u, либо маскированные бинарные данные, либо пусто)
|
||||
ContentType string `json:"contentType"` // MIME-тип тела ответа
|
||||
Tags []string `json:"tags"` // Список тегов канала
|
||||
CheckedAt int64 `json:"checkedAt"` // Время проверки в формате UNIX timestamp
|
||||
}
|
||||
|
||||
// Playlist - структура для хранения информации о плейлисте
|
||||
type Playlist struct {
|
||||
Code string `json:"code"` // Код плейлиста (из ini-файла)
|
||||
Name string `json:"name"` // Название плейлиста (из ini-файла)
|
||||
Description string `json:"description"` // Описание плейлиста (из ini-файла)
|
||||
Url string `json:"url"` // URL плейлиста
|
||||
Source string `json:"source"` // Источник плейлиста (из ini-файла)
|
||||
Content string `json:"content"` // Содержимое плейлиста (m3u, m3u8)
|
||||
IsOnline bool `json:"isOnline"` // Признак доступности плейлиста
|
||||
Attributes map[string]string `json:"attributes"` // Атрибуты тега #EXTM3U
|
||||
Groups map[string]Group `json:"groups"` // Группы каналов (по тегам #EXTGRP и атрибутам tvg-group тегов #EXTINF)
|
||||
Channels map[string]Channel `json:"channels"` // Каналы
|
||||
OnlineCount int `json:"onlineCount"` // Количество рабочих каналов
|
||||
OfflineCount int `json:"offlineCount"` // Количество нерабочих каналов
|
||||
CheckedAt int64 `json:"checkedAt"` // Время проверки в формате UNIX timestamp
|
||||
}
|
||||
|
||||
// tmpChannel хранит временные данные о канале, который обрабатывается в Parse
|
||||
var tmpChannel = Channel{}
|
||||
|
||||
// MakeFromFile создаёт экземпляр плейлиста из файла
|
||||
func MakeFromFile(filepath string) (Playlist, error) {
|
||||
expandedPath, err := utils.ExpandPath(filepath)
|
||||
if err != nil {
|
||||
return Playlist{}, errors.New("File read error: " + err.Error())
|
||||
}
|
||||
|
||||
_, err = os.Stat(expandedPath)
|
||||
if err != nil {
|
||||
return Playlist{}, errors.New("File read error: " + err.Error())
|
||||
}
|
||||
|
||||
playlist := Playlist{
|
||||
Code: "",
|
||||
Name: "",
|
||||
Description: "Playlist from filesystem",
|
||||
Url: expandedPath,
|
||||
Source: "-f",
|
||||
IsOnline: true,
|
||||
}
|
||||
|
||||
return playlist, playlist.ReadFromFs()
|
||||
}
|
||||
|
||||
// MakeFromUrl создаёт экземпляр плейлиста из URL-адреса
|
||||
func MakeFromUrl(url string) (Playlist, error) {
|
||||
playlist := Playlist{
|
||||
Code: "",
|
||||
Name: "",
|
||||
Description: "Remote playlist",
|
||||
Url: url,
|
||||
Source: "-u",
|
||||
IsOnline: true,
|
||||
}
|
||||
|
||||
return playlist, nil
|
||||
}
|
||||
|
||||
// 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)
|
||||
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], " ")
|
||||
}
|
||||
|
||||
regex := regexp.MustCompile(`['"]?\s*,\s*(.+)`)
|
||||
regexMatches := regex.FindAllStringSubmatch(line, -1)
|
||||
return regexMatches[0][1]
|
||||
}
|
||||
|
||||
// Download загружает плейлист по URL-адресу
|
||||
func (pls *Playlist) Download() error {
|
||||
content, err := utils.Fetch(pls.Url)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
pls.Content = string(content)
|
||||
return nil
|
||||
}
|
||||
|
||||
// ReadFromFs читает плейлист из файла
|
||||
func (pls *Playlist) ReadFromFs() error {
|
||||
content, err := os.ReadFile(pls.Url)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
pls.Content = string(content)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Parse разбирает плейлист
|
||||
func (pls *Playlist) Parse() Playlist {
|
||||
isChannel := false
|
||||
pls.Channels = make(map[string]Channel)
|
||||
pls.Groups = make(map[string]Group)
|
||||
|
||||
content := pls.Content
|
||||
content = strings.ReplaceAll(content, "\r\n", "\n") // replace windows line endings
|
||||
content = strings.ReplaceAll(content, "\xef\xbb\xbf", "") // remove UTF8 BOM
|
||||
|
||||
for _, line := range strings.Split(content, "\n") {
|
||||
line = strings.Trim(line, "\t\r\n ")
|
||||
if line == "" || line == "#EXTM3U" {
|
||||
continue
|
||||
}
|
||||
|
||||
if strings.HasPrefix(line, "#EXTM3U") {
|
||||
pls.Attributes = parseAttributes(content)
|
||||
continue
|
||||
}
|
||||
|
||||
if strings.HasPrefix(line, "#EXTINF") {
|
||||
isChannel = true
|
||||
tmpChannel.Attributes = parseAttributes(line)
|
||||
tmpChannel.Title = parseName(line)
|
||||
|
||||
if tmpChannel.Title == "" {
|
||||
if tvgid, ok := tmpChannel.Attributes["tvg-id"]; ok {
|
||||
tmpChannel.Title = "(канал без названия, tvg-id=" + tvgid + ")"
|
||||
} else {
|
||||
tmpChannel.Title = "(канал без названия, tvg-id неизвестен)"
|
||||
}
|
||||
}
|
||||
|
||||
if groupName, ok := tmpChannel.Attributes["group-title"]; ok {
|
||||
id := utils.Md5str(groupName)
|
||||
tmpChannel.GroupId = id
|
||||
pls.Groups[id] = Group{
|
||||
Id: id,
|
||||
Name: groupName,
|
||||
Attributes: nil,
|
||||
}
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
if isChannel && strings.HasPrefix(line, "#EXTGRP") {
|
||||
parts := strings.Split(line, ":")
|
||||
groupName := strings.Trim(parts[1], " ")
|
||||
id := utils.Md5str(groupName)
|
||||
tmpChannel.GroupId = id
|
||||
pls.Groups[id] = Group{
|
||||
Id: id,
|
||||
Name: groupName,
|
||||
Attributes: nil,
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
if isChannel && strings.HasPrefix(line, "http") {
|
||||
tmpChannel.URL = strings.Trim(line, " ")
|
||||
tmpChannel.Id = utils.Md5str(tmpChannel.URL)
|
||||
if tmpChannel.Id != "" {
|
||||
pls.Channels[tmpChannel.Id] = tmpChannel
|
||||
isChannel = false
|
||||
tmpChannel = Channel{}
|
||||
tmpChannel.Attributes = make(map[string]string)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return *pls
|
||||
}
|
||||
87
app/tagfile/tagfile.go
Normal file
87
app/tagfile/tagfile.go
Normal file
@@ -0,0 +1,87 @@
|
||||
/*
|
||||
* Copyright (c) 2025, Антон Аксенов
|
||||
* This file is part of iptvc project
|
||||
* MIT License: https://git.axenov.dev/IPTV/iptvc/src/branch/master/LICENSE
|
||||
*/
|
||||
|
||||
package tagfile
|
||||
|
||||
import (
|
||||
"axenov/iptv-checker/app/playlist"
|
||||
"axenov/iptv-checker/app/utils"
|
||||
"encoding/json"
|
||||
"log"
|
||||
"os"
|
||||
"regexp"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// TagBlock описывает объект с набором тегов, который подходит для каналов по регулярному выражению
|
||||
type TagBlock struct {
|
||||
TvgId string `json:"tvg-id"`
|
||||
Title string `json:"title"`
|
||||
Tags []string `json:"tags"`
|
||||
}
|
||||
|
||||
// GetTags возвращает теги, соответствующие каналу
|
||||
func (block *TagBlock) GetTags(ch playlist.Channel) []string {
|
||||
var regex *regexp.Regexp
|
||||
var checkString string
|
||||
var err error
|
||||
result := make([]string, 0)
|
||||
|
||||
if block.TvgId != "" {
|
||||
regex, err = regexp.Compile(block.TvgId)
|
||||
if err != nil {
|
||||
return result
|
||||
}
|
||||
if _, ok := ch.Attributes["tvg-id"]; !ok {
|
||||
return result
|
||||
}
|
||||
checkString = ch.Attributes["tvg-id"]
|
||||
if checkString == "" {
|
||||
return result
|
||||
}
|
||||
} else if block.Title != "" {
|
||||
regex, err = regexp.Compile(block.Title)
|
||||
if err != nil {
|
||||
return result
|
||||
}
|
||||
checkString = ch.Title
|
||||
} else {
|
||||
return result
|
||||
}
|
||||
|
||||
checkString = strings.ToLower(checkString)
|
||||
check := regex.MatchString(checkString)
|
||||
if !check {
|
||||
return result
|
||||
}
|
||||
return block.Tags
|
||||
}
|
||||
|
||||
// Init инициализирует объекты тегов из тегфайла
|
||||
func Init(path string) []TagBlock {
|
||||
pathNormalized, _ := utils.ExpandPath(path)
|
||||
_, err := os.Stat(pathNormalized)
|
||||
if err != nil {
|
||||
log.Println("Warning: tagfile load error (", err, "), all channels will be untagged")
|
||||
return nil
|
||||
}
|
||||
|
||||
content, err := os.ReadFile(pathNormalized)
|
||||
if err != nil {
|
||||
log.Println("Warning: tagfile load error (", err, "), all channels will be untagged")
|
||||
return nil
|
||||
}
|
||||
|
||||
var blocks []TagBlock
|
||||
err = json.Unmarshal(content, &blocks)
|
||||
if err != nil {
|
||||
log.Println("Warning: tagfile load error (", err, "), all channels will be untagged")
|
||||
return nil
|
||||
}
|
||||
|
||||
//TODO валидация полей: обязательны tvg-id или title, tags может быть пустым
|
||||
return blocks
|
||||
}
|
||||
76
app/utils/utils.go
Normal file
76
app/utils/utils.go
Normal file
@@ -0,0 +1,76 @@
|
||||
/*
|
||||
* Copyright (c) 2025, Антон Аксенов
|
||||
* This file is part of iptvc project
|
||||
* MIT License: https://git.axenov.dev/IPTV/iptvc/src/branch/master/LICENSE
|
||||
*/
|
||||
|
||||
package utils
|
||||
|
||||
import (
|
||||
"crypto/md5"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// ExpandPath возвращает полный путь к файлу, где ~ заменяется на домашнюю папку пользователя
|
||||
func ExpandPath(path string) (string, error) {
|
||||
homepath, err := os.UserHomeDir()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
newpath, err := filepath.Abs(strings.Replace(path, "~", homepath, 1))
|
||||
return newpath, err
|
||||
}
|
||||
|
||||
// ArrayUnique возвращает массив уникальных элементов
|
||||
func ArrayUnique(arr []string) []string {
|
||||
size := len(arr)
|
||||
result := make([]string, 0, size)
|
||||
temp := map[string]struct{}{}
|
||||
for i := 0; i < size; i++ {
|
||||
if _, ok := temp[arr[i]]; ok != true {
|
||||
temp[arr[i]] = struct{}{}
|
||||
result = append(result, arr[i])
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// Fetch выполняет GET запрос и возвращает результат в виде массива байт
|
||||
func Fetch(url string) ([]byte, error) {
|
||||
req, err := http.NewRequest("GET", url, nil)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
req.Header.Set(
|
||||
"User-Agent",
|
||||
"Mozilla/5.0 WINK/1.31.1 (AndroidTV/9) HlsWinkPlayer",
|
||||
)
|
||||
|
||||
httpClient := http.Client{Timeout: 5 * time.Second}
|
||||
resp, err := httpClient.Do(req)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return nil, fmt.Errorf("HTTP status %d", resp.StatusCode)
|
||||
}
|
||||
|
||||
return io.ReadAll(resp.Body)
|
||||
}
|
||||
|
||||
// Md5str возвращает хэш строки в виде строки
|
||||
func Md5str(str string) string {
|
||||
hash := md5.Sum([]byte(str))
|
||||
return hex.EncodeToString(hash[:])
|
||||
}
|
||||
Reference in New Issue
Block a user