We don't need to close the channels on stopping a task. We use a Context to exit from the task results loop.
193 lines
4.5 KiB
Go
193 lines
4.5 KiB
Go
// Copyright 2025 The OpenSnitch Authors. All rights reserved.
|
|
// Use of this source code is governed by the GPLv3
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package downloader
|
|
|
|
import (
|
|
"context"
|
|
//"encoding/json"
|
|
//"fmt"
|
|
"sync"
|
|
"time"
|
|
//"unsafe"
|
|
|
|
"github.com/evilsocket/opensnitch/daemon/core"
|
|
"github.com/evilsocket/opensnitch/daemon/log"
|
|
"github.com/evilsocket/opensnitch/daemon/tasks/base"
|
|
)
|
|
|
|
var (
|
|
// Name identifies the type of task of the instance.
|
|
Name = "downloader"
|
|
|
|
DefaultInterval = "6h"
|
|
DefaultTimeout = "5s"
|
|
|
|
SuccessMsg = "[blocklists] lists updated"
|
|
)
|
|
|
|
// Downloader downloads files at interval times.
|
|
type Downloader struct {
|
|
base.TaskBase
|
|
|
|
mu *sync.RWMutex
|
|
Ticker *time.Ticker
|
|
Config DownloaderConfig
|
|
Urls map[string]string
|
|
}
|
|
|
|
// New returns a new Downloader
|
|
func New(config map[string]interface{}, stopOnDisconnect bool) *Downloader {
|
|
|
|
cfg, err := loadConfig(config)
|
|
if err != nil {
|
|
log.Warning("Downloader config warning: %s", err)
|
|
}
|
|
log.Debug("[Downloader] New: %s -> %+v", Name, cfg)
|
|
return &Downloader{
|
|
TaskBase: base.TaskBase{
|
|
ID: base.DOWNLOADER,
|
|
Name: Name,
|
|
Results: make(chan interface{}),
|
|
Errors: make(chan error),
|
|
StopOnDisconnect: stopOnDisconnect,
|
|
},
|
|
mu: &sync.RWMutex{},
|
|
Urls: make(map[string]string),
|
|
Config: cfg,
|
|
}
|
|
}
|
|
|
|
// Start ...
|
|
func (pm *Downloader) Start(ctx context.Context, cancel context.CancelFunc) error {
|
|
pm.mu.Lock()
|
|
|
|
pm.Ctx = ctx
|
|
pm.Cancel = cancel
|
|
|
|
log.Debug("[Downloader] config: %s\n%+v\n", pm.Name, pm.Config)
|
|
|
|
interval, err := pm.parseInterval()
|
|
if err != nil {
|
|
log.Warning("[Downloader] Invalid interval: %s", err)
|
|
}
|
|
pm.Ticker = time.NewTicker(interval)
|
|
timeout, err := pm.parseTimeout()
|
|
if err != nil {
|
|
log.Warning("[Downloader] Invalid timeout")
|
|
}
|
|
pm.loadUrls()
|
|
|
|
pm.mu.Unlock()
|
|
|
|
downMgr := NewDownloaderMgr(pm.Urls, timeout)
|
|
progressExit := make(chan struct{})
|
|
go func(ctx context.Context) {
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
goto Exit
|
|
default:
|
|
// TODO: errors counter, and exit on errors > X
|
|
// URLs may stop working, cert errors, etc.
|
|
start := time.Now()
|
|
log.Debug("[Downloader] urls: %+v, %v\n", pm.Config, time.Since(start))
|
|
|
|
// this operation may last a lot of time. It depends on the download speed, the amount of urls, etc.
|
|
onFinish := downMgr.Start()
|
|
results := ""
|
|
errors := 0
|
|
go func(ctx context.Context) {
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
goto downFinish
|
|
case <-progressExit:
|
|
goto downFinish
|
|
case result := <-downMgr.Progress():
|
|
// TODO: reply with a JSON so the GUI can parse and show the results per list.
|
|
/*pJSON, err := json.Marshal(result)
|
|
if err != nil {
|
|
log.Debug("[Downloader] error parsing error: %s\n", err)
|
|
pm.TaskBase.Errors <- err
|
|
continue
|
|
}*/
|
|
log.Debug("[Downloader] finished: %d bytes, %s\n", result.Bytes, result.URL)
|
|
|
|
if result.Error != nil || result.Bytes == 0 {
|
|
errors++
|
|
results = core.ConcatStrings(results, ", ", result.URL)
|
|
}
|
|
}
|
|
}
|
|
downFinish:
|
|
log.Debug("[tasks.Downloader] stopped")
|
|
}(ctx)
|
|
onFinish.Wait()
|
|
progressExit <- struct{}{}
|
|
|
|
if pm.Config.Notify.Enabled {
|
|
if errors > 0 {
|
|
results = core.ConcatStrings("\n\nErrors:\n", results)
|
|
}
|
|
pm.TaskBase.Results <- core.ConcatStrings(SuccessMsg, results)
|
|
pm.TaskBase.Results <- base.TaskResults{Type: 9999, Data: core.ConcatStrings(SuccessMsg, results)}
|
|
}
|
|
|
|
log.Debug("[Downloader] finished (%d): %s", len(pm.Urls), results)
|
|
|
|
// TODO: parse notify
|
|
|
|
<-pm.Ticker.C
|
|
}
|
|
}
|
|
Exit:
|
|
log.Debug("[tasks.Downloader] stopped: %+v", pm.Config)
|
|
}(ctx)
|
|
return err
|
|
}
|
|
|
|
func (pm *Downloader) GetName() string {
|
|
return pm.Name
|
|
}
|
|
|
|
// Pause stops temporarily the task. For example it might be paused when the
|
|
// connection with the GUI (server) is closed.
|
|
func (pm *Downloader) Pause() error {
|
|
return nil
|
|
}
|
|
|
|
// Resume stopped tasks.
|
|
func (pm *Downloader) Resume() error {
|
|
return nil
|
|
}
|
|
|
|
// Stop ...
|
|
func (pm *Downloader) Stop() error {
|
|
pm.mu.Lock()
|
|
defer pm.mu.Unlock()
|
|
log.Debug("Downloader.Stop() %s", pm.Name)
|
|
|
|
/*if pm.StopOnDisconnect {
|
|
log.Debug("[task.Downloader] ignoring Stop()")
|
|
return nil
|
|
}*/
|
|
if pm.Ticker != nil {
|
|
pm.Ticker.Stop()
|
|
}
|
|
if pm.Cancel != nil {
|
|
pm.Cancel()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Results ...
|
|
func (pm *Downloader) Results() <-chan interface{} {
|
|
return pm.TaskBase.Results
|
|
}
|
|
|
|
// Errors ...
|
|
func (pm *Downloader) Errors() <-chan error {
|
|
return pm.TaskBase.Errors
|
|
}
|