refactor: package

This commit is contained in:
liwei committed 2021-03-25 19:38:23 +08:00
1 parent 359f28bb1f
commit ede6a9834d
55 files changed
+279 -237

No files matched your search

+194
View File
@@ -0,0 +1,194 @@
package download
import (
"errors"
"github.com/google/uuid"
"github.com/monkeyWie/gopeed-core/internal/controller"
"github.com/monkeyWie/gopeed-core/internal/fetcher"
"github.com/monkeyWie/gopeed-core/internal/protocol/http"
"github.com/monkeyWie/gopeed-core/pkg/base"
"github.com/monkeyWie/gopeed-core/pkg/util"
"net/url"
"strings"
"sync"
"time"
)
type FetcherBuilder func() (protocols []string, builder func() fetcher.Fetcher)
type TaskInfo struct {
ID string
Res *base.Resource
Opts *base.Options
Status base.Status
Files map[string]*base.FileInfo
Progress *Progress
fetcher fetcher.Fetcher
timer *util.Timer
locker *sync.Mutex
}
type Progress struct {
// 下载耗时(纳秒)
Used int64
// 每秒下载字节数
Speed int64
// 已下载的字节数
Downloaded int64
}
type Downloader struct {
*controller.DefaultController
fetchBuilders map[string]func() fetcher.Fetcher
tasks map[string]*TaskInfo
listener func(taskInfo *TaskInfo, eventKey EventKey)
}
var DefaultDownloader = NewDownloader(http.FetcherBuilder)
func NewDownloader(fbs ...FetcherBuilder) *Downloader {
d := &Downloader{DefaultController: controller.NewController()}
d.fetchBuilders = make(map[string]func() fetcher.Fetcher)
for _, f := range fbs {
protocols, builder := f()
for _, p := range protocols {
d.fetchBuilders[strings.ToUpper(p)] = builder
}
}
d.tasks = make(map[string]*TaskInfo)
// 每秒统计一次下载速度
go func() {
for {
if len(d.tasks) > 0 {
for _, task := range d.tasks {
if task.Status == base.DownloadStatusDone ||
task.Status == base.DownloadStatusError ||
task.Status == base.DownloadStatusPause {
continue
}
current := task.fetcher.Progress().TotalDownloaded()
task.Progress.Used = task.timer.Used()
task.Progress.Speed = current - task.Progress.Downloaded
task.Progress.Downloaded = current
d.emit(task, EventKeyProgress)
}
}
time.Sleep(time.Second)
}
}()
return d
}
func (d *Downloader) buildFetcher(URL string) (fetcher.Fetcher, error) {
url, err := url.Parse(URL)
if err != nil {
return nil, err
}
if fetchBuilder, ok := d.fetchBuilders[strings.ToUpper(url.Scheme)]; ok {
fetcher := fetchBuilder()
fetcher.Setup(d.DefaultController)
return fetcher, nil
}
return nil, errors.New("unsupported protocol")
}
func (d *Downloader) Resolve(req *base.Request) (*base.Resource, error) {
fetcher, err := d.buildFetcher(req.URL)
if err != nil {
return nil, err
}
return fetcher.Resolve(req)
}
func (d *Downloader) Create(res *base.Resource, opts *base.Options) (err error) {
fetcher, err := d.buildFetcher(res.Req.URL)
if err != nil {
return
}
err = fetcher.Create(res, opts)
if err != nil {
return
}
id := uuid.New().String()
task := &TaskInfo{
ID: id,
Res: res,
Opts: opts,
Status: base.DownloadStatusReady,
Progress: &Progress{},
fetcher: fetcher,
timer: &util.Timer{},
locker: new(sync.Mutex),
}
d.tasks[id] = task
task.timer.Start()
d.emit(task, EventKeyStart)
err = fetcher.Start()
if err != nil {
d.emit(task, EventKeyError)
return
}
go func() {
err = fetcher.Wait()
if err != nil {
d.emit(task, EventKeyError)
} else {
task.Progress.Used = task.timer.Used()
if task.Res.TotalSize == 0 {
task.Res.TotalSize = task.fetcher.Progress().TotalDownloaded()
}
used := task.Progress.Used / int64(time.Second)
if used == 0 {
used = 1
}
task.Progress.Speed = task.Res.TotalSize / used
task.Progress.Downloaded = task.Res.TotalSize
d.emit(d.tasks[id], EventKeyDone)
}
}()
return
}
func (d *Downloader) Pause(id string) {
task := d.tasks[id]
task.locker.Lock()
defer task.locker.Unlock()
task.timer.Pause()
task.fetcher.Pause()
d.emit(task, EventKeyPause)
}
func (d *Downloader) Continue(id string) {
task := d.tasks[id]
task.locker.Lock()
defer task.locker.Unlock()
task.timer.Continue()
task.fetcher.Continue()
d.emit(task, EventKeyContinue)
}
func (d *Downloader) Listener(fn func(taskInfo *TaskInfo, eventKey EventKey)) {
d.listener = fn
}
func (d *Downloader) emit(taskInfo *TaskInfo, eventKey EventKey) {
if d.listener != nil {
d.listener(taskInfo, eventKey)
}
}
// Resolve 解析资源
func Resolve(url string, extra ...interface{}) (*base.Resource, error) {
var e interface{}
if len(extra) == 0 {
e = nil
} else {
e = extra[0]
}
return DefaultDownloader.Resolve(&base.Request{
URL: url,
Extra: e,
})
}
+75
View File
@@ -0,0 +1,75 @@
package download
import (
"github.com/monkeyWie/gopeed-core/internal/protocol/http"
"github.com/monkeyWie/gopeed-core/pkg/base"
"github.com/monkeyWie/gopeed-core/pkg/test"
"reflect"
"sync"
"testing"
)
func TestDownloader_Resolve(t *testing.T) {
listener := test.StartTestFileServer()
defer listener.Close()
downloader := NewDownloader(http.FetcherBuilder)
req := &base.Request{
URL: "http://" + listener.Addr().String() + "/" + test.BuildName,
}
res, err := downloader.Resolve(req)
if err != nil {
t.Fatal(err)
}
want := &base.Resource{
Req: req,
TotalSize: test.BuildSize,
Range: true,
Files: []*base.FileInfo{
{
Name: test.BuildName,
Path: "",
Size: test.BuildSize,
},
},
}
if !reflect.DeepEqual(res, want) {
t.Errorf("Resolve error = %s, want %s", test.ToJson(res), test.ToJson(want))
}
}
func TestDownloader_Create(t *testing.T) {
listener := test.StartTestFileServer()
defer listener.Close()
downloader := NewDownloader(http.FetcherBuilder)
req := &base.Request{
URL: "http://" + listener.Addr().String() + "/" + test.BuildName,
}
res, err := downloader.Resolve(req)
if err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
wg.Add(1)
downloader.Listener(func(taskInfo *TaskInfo, eventKey EventKey) {
if eventKey == EventKeyDone {
wg.Done()
}
})
err = downloader.Create(res, &base.Options{
Path: test.Dir,
Name: test.DownloadName,
Connections: 4,
})
if err != nil {
t.Fatal(err)
}
wg.Wait()
want := test.FileMd5(test.BuildFile)
got := test.FileMd5(test.DownloadFile)
if want != got {
t.Errorf("Download error = %v, want %v", got, want)
}
}
+17
View File
@@ -0,0 +1,17 @@
package download
type EventKey string
const (
EventKeyStart = "start"
EventKeyPause = "pause"
EventKeyContinue = "continue"
EventKeyProgress = "progress"
EventKeyError = "error"
EventKeyDone = "done"
)
type Event struct {
EventKey
TaskInfo
}