Fix the ui progress panic with multiple threads (#99)

* Fix the ui progress panic with multiple threads

* Close the ui process when it is done

* Fix the process close issues

* Avoid using a global uiprogress instead of a new

* Add comments

Author: LinuxSuRen

pkg/http.go

@@ -43,7 +43,8 @@ func DownloadFileWithMultipleThreadKeepParts(targetURL, targetFilePath string, t
 
 // DownloadWithContinue downloads the files continuously
 func DownloadWithContinue(targetURL, output string, index, continueAt, end int64, showProgress bool) (err error) {
-	return net.DownloadWithContinue(targetURL, output, index, continueAt, end, showProgress)
+	downloader := &net.ContinueDownloader{}
+	return downloader.DownloadWithContinue(targetURL, output, index, continueAt, end, showProgress)
 }
 
 // DetectSize returns the size of target resource

pkg/net/http.go

@@ -45,8 +45,9 @@ type HTTPDownloader struct {
 	Timeout     int
 	MaxAttempts int
 
-	Debug        bool
-	RoundTripper http.RoundTripper
+	Debug             bool
+	RoundTripper      http.RoundTripper
+	progressIndicator *ProgressIndicator
 }
 
 // SetProxy set the proxy for a http
@@ -153,14 +154,14 @@ func (h *HTTPDownloader) DownloadFile() error {
 	if h.Title == "" {
 		h.Title = "Downloading"
 	}
-	writer := &ProgressIndicator{
+	h.progressIndicator = &ProgressIndicator{
 		Title: h.Title,
 	}
 	if showProgress {
 		if total, ok := resp.Header["Content-Length"]; ok && len(total) > 0 {
 			fileLength, err := strconv.ParseInt(total[0], 10, 64)
 			if err == nil {
-				writer.Total = float64(fileLength)
+				h.progressIndicator.Total = float64(fileLength)
 			}
 		}
 	}
@@ -176,14 +177,14 @@ func (h *HTTPDownloader) DownloadFile() error {
 		return err
 	}
 
-	writer.Writer = out
+	h.progressIndicator.Writer = out
 
 	if showProgress {
-		writer.Init()
+		h.progressIndicator.Init()
 	}
 
 	// Write the body to file
-	_, err = io.Copy(writer, resp.Body)
+	_, err = io.Copy(h.progressIndicator, resp.Body)
 	return err
 }
 
@@ -219,13 +220,16 @@ func DownloadFileWithMultipleThreadKeepParts(targetURL, targetFilePath string, t
 				}
 				start := unit * int64(index)
 
-				if downloadErr := DownloadWithContinue(targetURL, fmt.Sprintf("%s-%d", targetFilePath, index), int64(index), start, end, showProgress); downloadErr != nil {
+				downloader := &ContinueDownloader{}
+				if downloadErr := downloader.DownloadWithContinue(targetURL, fmt.Sprintf("%s-%d", targetFilePath, index),
+					int64(index), start, end, showProgress); downloadErr != nil {
 					fmt.Println(downloadErr)
 				}
 			}(i, &wg)
 		}
 
 		wg.Wait()
+		ProgressIndicator{}.Close()
 
 		// concat all these partial files
 		var f *os.File
@@ -251,33 +255,39 @@ func DownloadFileWithMultipleThreadKeepParts(targetURL, targetFilePath string, t
 		}
 	} else {
 		fmt.Println("cannot download it using multiple threads, failed to one")
-		err = DownloadWithContinue(targetURL, targetFilePath, -1, 0, 0, true)
+		downloader := &ContinueDownloader{}
+		err = downloader.DownloadWithContinue(targetURL, targetFilePath, -1, 0, 0, true)
 	}
 	return
 }
 
+// ContinueDownloader is a downloader which support continuously download
+type ContinueDownloader struct {
+	downloader *HTTPDownloader
+}
+
 // DownloadWithContinue downloads the files continuously
-func DownloadWithContinue(targetURL, output string, index, continueAt, end int64, showProgress bool) (err error) {
-	downloader := HTTPDownloader{
+func (c *ContinueDownloader) DownloadWithContinue(targetURL, output string, index, continueAt, end int64, showProgress bool) (err error) {
+	c.downloader = &HTTPDownloader{
 		TargetFilePath: output,
 		URL:            targetURL,
 		ShowProgress:   showProgress,
 	}
 	if index >= 0 {
-		downloader.Title = fmt.Sprintf("Downloading part %d", index)
+		c.downloader.Title = fmt.Sprintf("Downloading part %d", index)
 	}
 
 	if continueAt >= 0 {
-		downloader.Header = make(map[string]string, 1)
+		c.downloader.Header = make(map[string]string, 1)
 
 		if end > continueAt {
-			downloader.Header["Range"] = fmt.Sprintf("bytes=%d-%d", continueAt, end)
+			c.downloader.Header["Range"] = fmt.Sprintf("bytes=%d-%d", continueAt, end)
 		} else {
-			downloader.Header["Range"] = fmt.Sprintf("bytes=%d-", continueAt)
+			c.downloader.Header["Range"] = fmt.Sprintf("bytes=%d-", continueAt)
 		}
 	}
 
-	if err = downloader.DownloadFile(); err != nil {
+	if err = c.downloader.DownloadFile(); err != nil {
 		err = fmt.Errorf("cannot download from %s, error: %v", targetURL, err)
 	}
 	return

pkg/net/progress.go

@@ -18,14 +18,20 @@ type ProgressIndicator struct {
 	bar   *uiprogress.Bar
 }
 
+var process *uiprogress.Progress
+
 // Init set the default value for progress indicator
 func (i *ProgressIndicator) Init() {
-	uiprogress.Start()             // start rendering
-	i.bar = uiprogress.AddBar(100) // Add a new bar
+	// start rendering
+	if process == nil {
+		process = uiprogress.New()
+		process.Start()
+	}
+	i.bar = process.AddBar(100) // Add a new bar
 
 	// optionally, append and prepend completion and elapsed time
 	i.bar.AppendCompleted()
-	// i.bar.PrependElapsed()
+	//i.bar.PrependElapsed()
 
 	if i.Title != "" {
 		i.bar.PrependFunc(func(_ *uiprogress.Bar) string {
@@ -34,6 +40,14 @@ func (i *ProgressIndicator) Init() {
 	}
 }
 
+// Close shutdowns the ui process
+func (i ProgressIndicator) Close() {
+	if process != nil {
+		process.Stop()
+		process = nil
+	}
+}
+
 // Write writes the progress
 func (i *ProgressIndicator) Write(p []byte) (n int, err error) {
 	n, err = i.Writer.Write(p)