test multiple

cmd/main.go

@@ -1,98 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"gitea.tbdevent.eu/ilbinek/reforger_utils"
-)
-
-const DEBUG = true
-
-func main() {
-	addonID := "BADC0DEDABBEDA5E"
-	version := "0.12.4573"
-
-	assetsReply, err := reforger_utils.DoAssetsRequest(addonID, version)
-	if err != nil {
-		panic(err)
-	}
-
-	downloadDir := filepath.Join("downloads", addonID)
-	if DEBUG {
-		if err := os.MkdirAll(downloadDir, os.ModePerm); err != nil {
-			panic(err)
-		}
-	}
-
-	bytesReply, err := json.MarshalIndent(assetsReply, "", "  ")
-	if err != nil {
-		panic(err)
-	}
-
-	if DEBUG {
-		if err := os.WriteFile(filepath.Join(downloadDir, "assets.json"), bytesReply, os.ModePerm); err != nil {
-			panic(err)
-		}
-	}
-
-	for _, asset := range assetsReply {
-		for _, file := range asset.Files {
-			manifest, err := reforger_utils.GetManifest(file.ManifestPath)
-			if err != nil {
-				panic(err)
-			}
-
-			if DEBUG {
-				// save manifest
-				var manifestBuf bytes.Buffer
-				manifestEncoder := json.NewEncoder(&manifestBuf)
-				manifestEncoder.SetIndent("", "  ")
-				if err := manifestEncoder.Encode(manifest); err != nil {
-					panic(err)
-				}
-
-				if err := os.WriteFile(filepath.Join(downloadDir, file.Name+".manifest.json"), manifestBuf.Bytes(), os.ModePerm); err != nil {
-					panic(err)
-				}
-			}
-			
-			downedFile, err := reforger_utils.Download(manifest, downloadDir, file.Name)
-			if err != nil {
-				panic(err)
-			}
-
-			if err := os.WriteFile(filepath.Join(downloadDir, file.Name), downedFile, os.ModePerm); err != nil {
-				panic(err)
-			}
-			
-			fmt.Println("Downloaded", file.Name, len(downedFile), "bytes")
-
-			if file.Name[len(file.Name)-4:] != ".pak" {
-				continue
-			}
-
-			pakInfo, err := reforger_utils.GetPakFileInfo(&downedFile)
-			if err != nil {
-				panic(err)
-			}
-
-			for _, entry := range pakInfo {
-				fmt.Printf(" - %s (offset: %d, size: %d)\n", entry.Name, entry.Offset, entry.Size)
-				if DEBUG {
-					entryData := downedFile[entry.Offset : entry.Offset+entry.Size]
-					path := filepath.Join("downloads", addonID, "extracted", entry.Name)
-					if err := os.MkdirAll(filepath.Dir(path), os.ModePerm); err != nil {
-						panic(err)
-					}
-					if err := os.WriteFile(path, entryData, os.ModePerm); err != nil {
-						panic(err)
-					}
-				}
-			}
-		}
-	}
-}

go.mod

@@ -1,5 +1,3 @@
 module gitea.tbdevent.eu/ilbinek/reforger_utils
 
 go 1.25.0
-
-require golang.org/x/net v0.44.0 // indirect

go.sum

@@ -1,2 +0,0 @@
-golang.org/x/net v0.44.0 h1:evd8IRDyfNBMBTTY5XRF1vaZlD+EmWx6x8PkhR04H/I=
-golang.org/x/net v0.44.0/go.mod h1:ECOoLqd5U3Lhyeyo/QDCEVQ4sNgYsqvCZ722XogGieY=

util.go

@@ -10,26 +10,11 @@ import (
 	"slices"
 	"strings"
 	"sync"
-
-	"golang.org/x/net/proxy"
 )
 
 var Debug = false
-var Tor = false
 var DownThreads = 8
 
-func getHttpClient() (*http.Client, error) {
-	if Tor {
-		dialer, err := proxy.SOCKS5("tcp", "127.0.0.1:9050", nil, proxy.Direct)
-		if err != nil {
-			return nil, err
-		}
-		transport := &http.Transport{Dial: dialer.Dial}
-		return &http.Client{Transport: transport}, nil
-	}
-	return http.DefaultClient, nil
-}
-
 func DoAssetsRequest(addonID, version string) (AssetsReply, error) {
 	url := "https://api-ar-workshop.bistudio.com/workshop-api/api/v3.0/s2s/assets/download-list"
 	body := `{"assets":{"` + addonID + `":"` + version + `"}}`
@@ -44,11 +29,7 @@ func DoAssetsRequest(addonID, version string) (AssetsReply, error) {
 	req.Header.Add("user-agent", "Arma Reforger/1.4.0.53 (Headless; Windows)")
 	req.Header.Add("content-length", fmt.Sprintf("%d", len(body)))
 
-	client, err := getHttpClient()
+	res, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return AssetsReply{}, err
-	}
-	res, err := client.Do(req)
 	if err != nil {
 		return AssetsReply{}, err
 	}
@@ -78,11 +59,7 @@ func GetManifest(manifestUrl string) (Manifest, error) {
 		return Manifest{}, err
 	}
 
-	client, err := getHttpClient()
+	res, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return Manifest{}, err
-	}
-	res, err := client.Do(req)
 	if err != nil {
 		return Manifest{}, err
 	}
@@ -137,61 +114,72 @@ func Download(manifest Manifest, downloadDir string, filen string) ([]byte, erro
 	ret := make([]byte, manifest.Size)
 	totalMB := float32(manifest.Size) / 1024.0 / 1024.0
 
-	// A channel to signal the main goroutine to check for errors
-	doneChan := make(chan bool)
-
 	var wg sync.WaitGroup
-	wg.Add(DownThreads)
 	var mu sync.Mutex
 
-	fragChan := make(chan Fragment, DownThreads)
+	fragmentsChan := make(chan Fragment, len(manifest.Fragments))
 	errChan := make(chan error, DownThreads)
 
-	// Start worker threads
+	// Start worker goroutines
 	for i := 0; i < DownThreads; i++ {
+		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for fragment := range fragChan {
+			for fragment := range fragmentsChan {
 				url := transformShaToURL(fragment.Sha512, fragment.Size)
 				content, err := getContent(url)
 				if err != nil {
+					// Handle error, maybe by sending it to an error channel
+					// For now, we'll just skip and print.
+					fmt.Printf("Error downloading fragment %s: %v\n", fragment.Sha512, err)
 					errChan <- err
-					return
 				}
+
 				mu.Lock()
-				downloaded += len(content) * len(fragment.Offsets)
+				// Safely write to the shared slice and update progress
 				for _, offset := range fragment.Offsets {
-					trackFrag = append(trackFrag, Frag{Offset: offset, Size: len(content)})
+					if offset+len(content) > len(ret) {
+						// Handle case where fragment is too large for the buffer
+						fmt.Printf("Fragment too large for buffer at offset %d\n", offset)
+						continue
+					}
 					copy(ret[offset:offset+len(content)], content)
 				}
-				percent := float32(downloaded) / float32(manifest.Size) * 100.0
+				downloaded += len(content) * len(fragment.Offsets)
+
+				// Print progress
 				downedMB := float32(downloaded) / 1024.0 / 1024.0
-				fmt.Printf("\r\033[32mDownloaded\033[0m %fMB/%fMB (\033[36m%.2f%%\033[0m) of \033[33m%s\033[0m", downedMB, totalMB, percent, filen)
+				percent := float32(downloaded) / float32(manifest.Size) * 100.0
+				fmt.Printf("\r\033[32mDownloaded\033[0m %.2fMB/%.2fMB (\033[36m%.2f%%\033[0m) of \033[33m%s\033[0m", downedMB, totalMB, percent, filen)
+
+				mu.Unlock()
+
+				// The Debug section can be safely moved here as well
+				if os.Getenv("DEBUG") == "true" { // Using env var for a cleaner check
+					mu.Lock() // Re-lock for file write
+					if err := os.WriteFile(filepath.Join(downloadDir, "fragments", filen, fmt.Sprintf("%d.%s.%d.bytes", fragment.Offsets[0], fragment.Sha512, fragment.Size)), content, os.ModePerm); err != nil {
+						fmt.Printf("Error saving file: %v\n", err)
+					}
 					mu.Unlock()
 				}
+			}
 		}()
 	}
 
-	// A separate goroutine to wait for all workers to finish and then close the error channel
+	// Send fragments to the channel
-	go func() {
-		wg.Wait()
-		close(doneChan)
-	}()
-
-	// Send fragments to workers
 	for _, fragment := range manifest.Fragments {
-		fragChan <- fragment
+		fragmentsChan <- fragment
 	}
-	close(fragChan)
+	close(fragmentsChan) // Close the channel to signal workers no more tasks are coming
 
-	// Wait for workers to finish or an error to occur
+	// Wait for all workers to finish
-	select {
+	wg.Wait()
-	case <-doneChan:
+
-		// All workers finished successfully
+	// Check for errors
-	case err := <-errChan:
+	if len(errChan) > 0 {
-		// An error occurred
+		return nil, <-errChan // Return the first error encountered
-		return nil, err
 	}
+	close(errChan)
 
 	// sort trackFrag by Offset
 	slices.SortFunc(trackFrag, func(a, b Frag) int {
@@ -222,11 +210,7 @@ func Download(manifest Manifest, downloadDir string, filen string) ([]byte, erro
 }
 
 func getContent(url string) ([]byte, error) {
-	client, err := getHttpClient()
+	resp, err := http.Get(url)
-	if err != nil {
-		return nil, err
-	}
-	resp, err := client.Get(url)
 	if err != nil {
 		return nil, err
 	}