Function tryExtractFiles

internal/extract.go:201–253

TODO : unit tests

(files []ReaderMaker,
	tarInterpreter TarInterpreter,
	downloadingConcurrency int)

// TODO : unit tests
func tryExtractFiles(files []ReaderMaker,
	tarInterpreter TarInterpreter,
	downloadingConcurrency int) (failed []ReaderMaker) {
	downloadingContext := context.TODO()
	downloadingSemaphore := semaphore.NewWeighted(int64(downloadingConcurrency))
	crypter := ConfigureCrypter()
	isFailed := sync.Map{}

	for _, file := range files {
		err := downloadingSemaphore.Acquire(downloadingContext, 1)
		if err != nil {
			tracelog.ErrorLogger.Println(err)
			return files //Should never happen, but if we are asked to cancel - consider all files unfinished
		}
		fileClosure := file

		go func() {
			defer downloadingSemaphore.Release(1)

			readCloser, err := fileClosure.Reader()
			if err == nil {
				defer utility.LoggedClose(readCloser, "")

				filePath := fileClosure.StoragePath()
				var extractingReader io.ReadCloser
				extractingReader, err = DecryptAndDecompressTar(readCloser, filePath, crypter)
				if err == nil {
					defer extractingReader.Close()
					err = extractFile(tarInterpreter, extractingReader, fileClosure)
					err = errors.Wrapf(err, "Extraction error in %s", filePath)
					tracelog.InfoLogger.Printf("Finished extraction of %s", filePath)
				}
			}

			if err != nil {
				isFailed.Store(fileClosure, true)
				tracelog.ErrorLogger.Println(err)
			}
		}()
	}

	err := downloadingSemaphore.Acquire(downloadingContext, int64(downloadingConcurrency))
	if err != nil {
		tracelog.ErrorLogger.Println(err)
		return files //Should never happen, but if we are asked to cancel - consider all files unfinished
	}

	isFailed.Range(func(failedFile, _ interface{}) bool {
		failed = append(failed, failedFile.(ReaderMaker))
		return true
	})
	return failed
}

func readTrailingZeros(r io.Reader) error {
	// on first iteration we read small chunk