Refactor SIP payload header parsing and extraction.

derkan · derkan · commit a53ea74737b7 · 2026-04-13T13:36:21.000+03:00
Consolidated SIP payload header parsing into a dedicated reusable function, reducing redundancy and improving maintainability. Updated the relevant tests and logic to leverage the new implementation, ensuring consistent behavior across SIP header extraction processes.
diff --git a/decompression.go b/decompression.go
@@ -10,6 +10,8 @@ import (
 	"github.com/xi2/xz"
 )
 
+type progressLogger func(format string, args ...any)
+
 func defaultTarReader(xzReader *xz.Reader) (func() (*tar.Header, error), func() io.Reader) {
 	tarReader := tar.NewReader(xzReader)
 
@@ -20,7 +22,7 @@ func defaultTarReader(xzReader *xz.Reader) (func() (*tar.Header, error), func()
 		}
 }
 
-func decompressTarXz(tarReader func(*xz.Reader) (func() (*tar.Header, error), func() io.Reader), path, extractPath string) error {
+func decompressTarXz(tarReader func(*xz.Reader) (func() (*tar.Header, error), func() io.Reader), path, extractPath string, logf progressLogger) error {
 	extractDirectory := filepath.Dir(extractPath)
 
 	if err := os.MkdirAll(extractDirectory, os.ModePerm); err != nil {
@@ -54,6 +56,7 @@ func decompressTarXz(tarReader func(*xz.Reader) (func() (*tar.Header, error), fu
 	}
 
 	readNext, reader := tarReader(xzReader)
+	entryCount := 0
 
 	for {
 		header, err := readNext()
@@ -79,6 +82,7 @@ func decompressTarXz(tarReader func(*xz.Reader) (func() (*tar.Header, error), fu
 
 		switch header.Typeflag {
 		case tar.TypeReg:
+			logProgress(logf, "extracting embedded postgres entry archive=%s entry=%s type=file target=%s size=%d", path, header.Name, finalPath, header.Size)
 			outFile, err := os.OpenFile(targetPath, os.O_CREATE|os.O_RDWR, os.FileMode(header.Mode))
 			if err != nil {
 				return errorExtractingPostgres(err)
@@ -92,6 +96,7 @@ func decompressTarXz(tarReader func(*xz.Reader) (func() (*tar.Header, error), fu
 				return errorExtractingPostgres(err)
 			}
 		case tar.TypeSymlink:
+			logProgress(logf, "extracting embedded postgres entry archive=%s entry=%s type=symlink target=%s link=%s", path, header.Name, finalPath, header.Linkname)
 			if err := os.RemoveAll(targetPath); err != nil {
 				return errorExtractingPostgres(err)
 			}
@@ -101,20 +106,32 @@ func decompressTarXz(tarReader func(*xz.Reader) (func() (*tar.Header, error), fu
 			}
 
 		case tar.TypeDir:
+			logProgress(logf, "extracting embedded postgres entry archive=%s entry=%s type=dir target=%s", path, header.Name, finalPath)
 			if err := os.MkdirAll(finalPath, os.FileMode(header.Mode)); err != nil {
 				return errorExtractingPostgres(err)
 			}
+			entryCount++
 			continue
 		}
 
 		if err := renameOrIgnore(targetPath, finalPath); err != nil {
 			return errorExtractingPostgres(err)
 		}
+		entryCount++
 	}
 
+	logProgress(logf, "finished extracting embedded postgres archive archive=%s destination=%s entries=%d", path, extractPath, entryCount)
+
 	return nil
 }
 
+func logProgress(logf progressLogger, format string, args ...any) {
+	if logf == nil {
+		return
+	}
+	logf(format, args...)
+}
+
 func errorUnableToExtract(cacheLocation, binariesPath string, err error) error {
 	return fmt.Errorf("unable to extract postgres archive %s to %s, if running parallel tests, configure RuntimePath to isolate testing directories, %w",
 		cacheLocation,
diff --git a/decompression_test.go b/decompression_test.go
@@ -2,6 +2,7 @@ package embeddedpostgres
 
 import (
 	"archive/tar"
+	"bytes"
 	"errors"
 	"fmt"
 	"io"
@@ -28,7 +29,7 @@ func Test_decompressTarXz(t *testing.T) {
 	archive, cleanUp := createTempXzArchive()
 	defer cleanUp()
 
-	err = decompressTarXz(defaultTarReader, archive, tempDir)
+	err = decompressTarXz(defaultTarReader, archive, tempDir, nil)
 
 	assert.NoError(t, err)
 
@@ -42,7 +43,7 @@ func Test_decompressTarXz(t *testing.T) {
 }
 
 func Test_decompressTarXz_ErrorWhenFileNotExists(t *testing.T) {
-	err := decompressTarXz(defaultTarReader, "/does-not-exist", "/also-fake")
+	err := decompressTarXz(defaultTarReader, "/does-not-exist", "/also-fake", nil)
 
 	assert.Error(t, err)
 	assert.Contains(
@@ -68,7 +69,7 @@ func Test_decompressTarXz_ErrorWhenErrorDuringRead(t *testing.T) {
 		return func() (*tar.Header, error) {
 			return nil, errors.New("oh noes")
 		}, nil
-	}, archive, tempDir)
+	}, archive, tempDir, nil)
 
 	assert.EqualError(t, err, "unable to extract postgres archive: oh noes")
 }
@@ -108,7 +109,7 @@ func Test_decompressTarXz_ErrorWhenFailedToReadFileToCopy(t *testing.T) {
 			}
 	}
 
-	err = decompressTarXz(fileBlockingExtractTarReader, archive, tempDir)
+	err = decompressTarXz(fileBlockingExtractTarReader, archive, tempDir, nil)
 
 	assert.Regexp(t, "^unable to extract postgres archive:.+$", err)
 }
@@ -145,7 +146,7 @@ func Test_decompressTarXz_ErrorWhenFileToCopyToNotExists(t *testing.T) {
 			}
 	}
 
-	err = decompressTarXz(fileBlockingExtractTarReader, archive, tempDir)
+	err = decompressTarXz(fileBlockingExtractTarReader, archive, tempDir, nil)
 
 	assert.Regexp(t, "^unable to extract postgres archive:.+$", err)
 }
@@ -180,7 +181,7 @@ func Test_decompressTarXz_ErrorWhenArchiveCorrupted(t *testing.T) {
 		panic(err)
 	}
 
-	err = decompressTarXz(defaultTarReader, archive, tempDir)
+	err = decompressTarXz(defaultTarReader, archive, tempDir, nil)
 
 	assert.EqualError(t, err, "unable to extract postgres archive: xz: data is corrupt")
 }
@@ -197,10 +198,26 @@ func Test_decompressTarXz_ErrorWithInvalidDestination(t *testing.T) {
 
 	op := fmt.Sprintf(path.Join(tempDir, "%c"), rune(0))
 
-	err = decompressTarXz(defaultTarReader, archive, op)
+	err = decompressTarXz(defaultTarReader, archive, op, nil)
 	assert.EqualError(
 		t,
 		err,
 		fmt.Sprintf("unable to extract postgres archive: mkdir %s: invalid argument", op),
 	)
 }
+
+func Test_decompressTarXz_LogsExtractedEntries(t *testing.T) {
+	tempDir := t.TempDir()
+	archive, cleanUp := createTempXzArchive()
+	defer cleanUp()
+
+	var logs bytes.Buffer
+	err := decompressTarXz(defaultTarReader, archive, tempDir, func(format string, args ...any) {
+		_, _ = fmt.Fprintf(&logs, format+"\n", args...)
+	})
+
+	require.NoError(t, err)
+	assert.Contains(t, logs.String(), "extracting embedded postgres entry")
+	assert.Contains(t, logs.String(), "entry=dir1/dir2/some_content")
+	assert.Contains(t, logs.String(), "finished extracting embedded postgres archive")
+}
diff --git a/embedded_postgres.go b/embedded_postgres.go
@@ -102,6 +102,15 @@ func (ep *EmbeddedPostgres) Start() error {
 		ep.config.binariesPath = ep.config.runtimePath
 	}
 
+	ep.logf(
+		"embedded postgres binary setup cache=%s cache_exists=%t runtime_path=%s binaries_path=%s data_path=%s",
+		cacheLocation,
+		cacheExists,
+		ep.config.runtimePath,
+		ep.config.binariesPath,
+		ep.config.dataPath,
+	)
+
 	if err := ep.downloadAndExtractBinary(cacheExists, cacheLocation); err != nil {
 		return err
 	}
@@ -159,21 +168,36 @@ func (ep *EmbeddedPostgres) downloadAndExtractBinary(cacheExists bool, cacheLoca
 	mu.Lock()
 	defer mu.Unlock()
 
-	_, binDirErr := os.Stat(filepath.Join(ep.config.binariesPath, "bin", "pg_ctl"))
+	pgCtlPath := filepath.Join(ep.config.binariesPath, "bin", "pg_ctl")
+	_, binDirErr := os.Stat(pgCtlPath)
 	if os.IsNotExist(binDirErr) {
 		if !cacheExists {
-			if err := ep.remoteFetchStrategy(); err != nil {
+			ep.logf("downloading embedded postgres archive cache=%s", cacheLocation)
+			if err := ep.remoteFetchStrategy(ep.logf); err != nil {
 				return err
 			}
+		} else {
+			ep.logf("using cached embedded postgres archive cache=%s", cacheLocation)
 		}
 
-		if err := decompressTarXz(defaultTarReader, cacheLocation, ep.config.binariesPath); err != nil {
+		ep.logf("extracting embedded postgres archive archive=%s destination=%s", cacheLocation, ep.config.binariesPath)
+		if err := decompressTarXz(defaultTarReader, cacheLocation, ep.config.binariesPath, ep.logf); err != nil {
 			return err
 		}
+		ep.logf("embedded postgres archive extracted archive=%s destination=%s", cacheLocation, ep.config.binariesPath)
+	} else {
+		ep.logf("embedded postgres binaries already available pg_ctl=%s", pgCtlPath)
 	}
 	return nil
 }
 
+func (ep *EmbeddedPostgres) logf(format string, args ...any) {
+	if ep == nil || ep.syncedLogger == nil {
+		return
+	}
+	ep.syncedLogger.logf(format, args...)
+}
+
 func (ep *EmbeddedPostgres) GetConnectionURL() string {
 	return ep.config.GetConnectionURL()
 }
diff --git a/embedded_postgres_test.go b/embedded_postgres_test.go
@@ -65,11 +65,11 @@ func Test_ErrorWhenPortAlreadyTaken(t *testing.T) {
 }
 
 func Test_ErrorWhenRemoteFetchError(t *testing.T) {
-	database := NewDatabase()
+	database := NewDatabase(DefaultConfig().Port(9875))
 	database.cacheLocator = func() (string, bool) {
 		return "", false
 	}
-	database.remoteFetchStrategy = func() error {
+	database.remoteFetchStrategy = func(progressLogger) error {
 		return errors.New("did not work")
 	}
 
@@ -328,7 +328,7 @@ func Test_CustomLog(t *testing.T) {
 	assert.Contains(t, lines, fmt.Sprintf("The files belonging to this database system will be owned by user \"%s\".", current.Username))
 	assert.Contains(t, lines, "syncing data to disk ... ok")
 	assert.Contains(t, lines, "server stopped")
-	assert.Less(t, len(lines), 55)
+	assert.Less(t, len(lines), 70)
 	assert.Greater(t, len(lines), 40)
 }
 
@@ -767,20 +767,20 @@ func Test_PrefetchedBinaries(t *testing.T) {
 		RuntimePath(runtimeTempDir))
 
 	// Download and unarchive postgres into the bindir.
-	if err := database.remoteFetchStrategy(); err != nil {
+	if err := database.remoteFetchStrategy(nil); err != nil {
 		panic(err)
 	}
 
 	cacheLocation, _ := database.cacheLocator()
-	if err := decompressTarXz(defaultTarReader, cacheLocation, binTempDir); err != nil {
+	if err := decompressTarXz(defaultTarReader, cacheLocation, binTempDir, nil); err != nil {
 		panic(err)
 	}
 
 	// Expect everything to work without cacheLocator and/or remoteFetch abilities.
 	database.cacheLocator = func() (string, bool) {
 		return "", false
 	}
-	database.remoteFetchStrategy = func() error {
+	database.remoteFetchStrategy = func(progressLogger) error {
 		return errors.New("did not work")
 	}
 
diff --git a/logging.go b/logging.go
@@ -61,6 +61,21 @@ func (s *syncedLogger) flush() error {
 	return nil
 }
 
+func (s *syncedLogger) logf(format string, args ...any) {
+	if s == nil || s.file == nil {
+		return
+	}
+	if _, err := fmt.Fprintf(s.file, format+"\n", args...); err != nil {
+		panic(err)
+	}
+	if err := s.file.Sync(); err != nil {
+		panic(err)
+	}
+	if err := s.flush(); err != nil {
+		panic(err)
+	}
+}
+
 func readLogsOrTimeout(logger *os.File) (logContent []byte, err error) {
 	logContent = []byte("logs could not be read")
 
diff --git a/remote_fetch.go b/remote_fetch.go
@@ -16,18 +16,19 @@ import (
 )
 
 // RemoteFetchStrategy provides a strategy to fetch a Postgres binary so that it is available for use.
-type RemoteFetchStrategy func() error
+type RemoteFetchStrategy func(progressLogger) error
 
 var freeBSDBinaryRepositoryURL = "https://web.sintel.com.tr/downloads/siper/pg"
 
 //nolint:funlen
 func defaultRemoteFetchStrategy(remoteFetchHost string, versionStrategy VersionStrategy, cacheLocator CacheLocator) RemoteFetchStrategy {
-	return func() error {
+	return func(logf progressLogger) error {
 		operatingSystem, architecture, version := versionStrategy()
 		cacheLocation, _ := cacheLocator()
 
 		if freeBSDDirectDownloadURL, ok := freeBSDBundleDownloadURL(operatingSystem, architecture); ok {
-			if err := downloadArchiveToCache(freeBSDDirectDownloadURL, cacheLocation); err != nil {
+			logProgress(logf, "downloading embedded postgres archive url=%s cache=%s", freeBSDDirectDownloadURL, cacheLocation)
+			if err := downloadArchiveToCache(freeBSDDirectDownloadURL, cacheLocation, logf); err != nil {
 				return err
 			}
 			return nil
@@ -41,6 +42,7 @@ func defaultRemoteFetchStrategy(remoteFetchHost string, versionStrategy VersionS
 			operatingSystem,
 			architecture,
 			version)
+		logProgress(logf, "downloading embedded postgres bundle url=%s cache=%s", jarDownloadURL, cacheLocation)
 
 		jarDownloadResponse, err := http.Get(jarDownloadURL)
 		if err != nil {
@@ -74,7 +76,7 @@ func defaultRemoteFetchStrategy(remoteFetchHost string, versionStrategy VersionS
 			}
 		}
 
-		return decompressResponse(jarBodyBytes, jarDownloadResponse.ContentLength, cacheLocator, jarDownloadURL)
+		return decompressResponse(jarBodyBytes, jarDownloadResponse.ContentLength, cacheLocator, jarDownloadURL, logf)
 	}
 }
 
@@ -89,7 +91,7 @@ func freeBSDBundleDownloadURL(operatingSystem, architecture string) (string, boo
 	}
 }
 
-func downloadArchiveToCache(downloadURL, cacheLocation string) error {
+func downloadArchiveToCache(downloadURL, cacheLocation string, logf progressLogger) error {
 	downloadResponse, err := http.Get(downloadURL)
 	if err != nil {
 		return fmt.Errorf("unable to connect to %s", downloadURL)
@@ -107,6 +109,7 @@ func downloadArchiveToCache(downloadURL, cacheLocation string) error {
 	if err := os.MkdirAll(filepath.Dir(cacheLocation), 0755); err != nil {
 		return errorExtractingPostgres(err)
 	}
+	logProgress(logf, "downloaded embedded postgres archive url=%s cache=%s bytes=%d", downloadURL, cacheLocation, len(archiveBytes))
 	return writeArchiveAtomically(cacheLocation, archiveBytes)
 }
 
@@ -149,7 +152,7 @@ func closeBody(resp *http.Response) func() {
 	}
 }
 
-func decompressResponse(bodyBytes []byte, contentLength int64, cacheLocator CacheLocator, downloadURL string) error {
+func decompressResponse(bodyBytes []byte, contentLength int64, cacheLocator CacheLocator, downloadURL string, logf progressLogger) error {
 	size := contentLength
 	// if the content length is not set (i.e. chunked encoding),
 	// we need to use the length of the bodyBytes otherwise
@@ -170,6 +173,7 @@ func decompressResponse(bodyBytes []byte, contentLength int64, cacheLocator Cach
 
 	for _, file := range zipReader.File {
 		if !file.FileHeader.FileInfo().IsDir() && strings.HasSuffix(file.FileHeader.Name, ".txz") {
+			logProgress(logf, "writing embedded postgres archive from bundle url=%s entry=%s cache=%s", downloadURL, file.FileHeader.Name, cacheLocation)
 			if err := decompressSingleFile(file, cacheLocation); err != nil {
 				return err
 			}
diff --git a/remote_fetch_test.go b/remote_fetch_test.go

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,8 @@ import (`
`10`	`10`	`"github.com/xi2/xz"`
`11`	`11`	`)`
`12`	`12`
	`13`	`+type progressLogger func(format string, args ...any)`
	`14`	`+`
`13`	`15`	`func defaultTarReader(xzReader xz.Reader) (func() (tar.Header, error), func() io.Reader) {`
`14`	`16`	`tarReader := tar.NewReader(xzReader)`
`15`	`17`
`@@ -20,7 +22,7 @@ func defaultTarReader(xzReader xz.Reader) (func() (tar.Header, error), func()`
`20`	`22`	`}`
`21`	`23`	`}`
`22`	`24`
`23`		`-func decompressTarXz(tarReader func(xz.Reader) (func() (tar.Header, error), func() io.Reader), path, extractPath string) error {`
	`25`	`+func decompressTarXz(tarReader func(xz.Reader) (func() (tar.Header, error), func() io.Reader), path, extractPath string, logf progressLogger) error {`
`24`	`26`	`extractDirectory := filepath.Dir(extractPath)`
`25`	`27`
`26`	`28`	`if err := os.MkdirAll(extractDirectory, os.ModePerm); err != nil {`
`@@ -54,6 +56,7 @@ func decompressTarXz(tarReader func(xz.Reader) (func() (tar.Header, error), fu`
`54`	`56`	`}`
`55`	`57`
`56`	`58`	`readNext, reader := tarReader(xzReader)`
	`59`	`+ entryCount := 0`
`57`	`60`
`58`	`61`	`for {`
`59`	`62`	`header, err := readNext()`
`@@ -79,6 +82,7 @@ func decompressTarXz(tarReader func(xz.Reader) (func() (tar.Header, error), fu`
`79`	`82`
`80`	`83`	`switch header.Typeflag {`
`81`	`84`	`case tar.TypeReg:`
	`85`	`+ logProgress(logf, "extracting embedded postgres entry archive=%s entry=%s type=file target=%s size=%d", path, header.Name, finalPath, header.Size)`
`82`	`86`	`outFile, err := os.OpenFile(targetPath, os.O_CREATE\|os.O_RDWR, os.FileMode(header.Mode))`
`83`	`87`	`if err != nil {`
`84`	`88`	`return errorExtractingPostgres(err)`
`@@ -92,6 +96,7 @@ func decompressTarXz(tarReader func(xz.Reader) (func() (tar.Header, error), fu`
`92`	`96`	`return errorExtractingPostgres(err)`
`93`	`97`	`}`
`94`	`98`	`case tar.TypeSymlink:`
	`99`	`+ logProgress(logf, "extracting embedded postgres entry archive=%s entry=%s type=symlink target=%s link=%s", path, header.Name, finalPath, header.Linkname)`
`95`	`100`	`if err := os.RemoveAll(targetPath); err != nil {`
`96`	`101`	`return errorExtractingPostgres(err)`
`97`	`102`	`}`
`@@ -101,20 +106,32 @@ func decompressTarXz(tarReader func(xz.Reader) (func() (tar.Header, error), fu`
`101`	`106`	`}`
`102`	`107`
`103`	`108`	`case tar.TypeDir:`
	`109`	`+ logProgress(logf, "extracting embedded postgres entry archive=%s entry=%s type=dir target=%s", path, header.Name, finalPath)`
`104`	`110`	`if err := os.MkdirAll(finalPath, os.FileMode(header.Mode)); err != nil {`
`105`	`111`	`return errorExtractingPostgres(err)`
`106`	`112`	`}`
	`113`	`+ entryCount++`
`107`	`114`	`continue`
`108`	`115`	`}`
`109`	`116`
`110`	`117`	`if err := renameOrIgnore(targetPath, finalPath); err != nil {`
`111`	`118`	`return errorExtractingPostgres(err)`
`112`	`119`	`}`
	`120`	`+ entryCount++`
`113`	`121`	`}`
`114`	`122`
	`123`	`+ logProgress(logf, "finished extracting embedded postgres archive archive=%s destination=%s entries=%d", path, extractPath, entryCount)`
	`124`	`+`
`115`	`125`	`return nil`
`116`	`126`	`}`
`117`	`127`
	`128`	`+func logProgress(logf progressLogger, format string, args ...any) {`
	`129`	`+ if logf == nil {`
	`130`	`+ return`
	`131`	`+ }`
	`132`	`+ logf(format, args...)`
	`133`	`+}`
	`134`	`+`
`118`	`135`	`func errorUnableToExtract(cacheLocation, binariesPath string, err error) error {`
`119`	`136`	`return fmt.Errorf("unable to extract postgres archive %s to %s, if running parallel tests, configure RuntimePath to isolate testing directories, %w",`
`120`	`137`	`cacheLocation,`
Original file line number	Diff line number	Diff line change
`@@ -65,11 +65,11 @@ func Test_ErrorWhenPortAlreadyTaken(t *testing.T) {`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`func Test_ErrorWhenRemoteFetchError(t *testing.T) {`
`68`		`- database := NewDatabase()`
	`68`	`+ database := NewDatabase(DefaultConfig().Port(9875))`
`69`	`69`	`database.cacheLocator = func() (string, bool) {`
`70`	`70`	`return "", false`
`71`	`71`	`}`
`72`		`- database.remoteFetchStrategy = func() error {`
	`72`	`+ database.remoteFetchStrategy = func(progressLogger) error {`
`73`	`73`	`return errors.New("did not work")`
`74`	`74`	`}`
`75`	`75`
`@@ -328,7 +328,7 @@ func Test_CustomLog(t *testing.T) {`
`328`	`328`	`assert.Contains(t, lines, fmt.Sprintf("The files belonging to this database system will be owned by user \"%s\".", current.Username))`
`329`	`329`	`assert.Contains(t, lines, "syncing data to disk ... ok")`
`330`	`330`	`assert.Contains(t, lines, "server stopped")`
`331`		`- assert.Less(t, len(lines), 55)`
	`331`	`+ assert.Less(t, len(lines), 70)`
`332`	`332`	`assert.Greater(t, len(lines), 40)`
`333`	`333`	`}`
`334`	`334`
`@@ -767,20 +767,20 @@ func Test_PrefetchedBinaries(t *testing.T) {`
`767`	`767`	`RuntimePath(runtimeTempDir))`
`768`	`768`
`769`	`769`	`// Download and unarchive postgres into the bindir.`
`770`		`- if err := database.remoteFetchStrategy(); err != nil {`
	`770`	`+ if err := database.remoteFetchStrategy(nil); err != nil {`
`771`	`771`	`panic(err)`
`772`	`772`	`}`
`773`	`773`
`774`	`774`	`cacheLocation, _ := database.cacheLocator()`
`775`		`- if err := decompressTarXz(defaultTarReader, cacheLocation, binTempDir); err != nil {`
	`775`	`+ if err := decompressTarXz(defaultTarReader, cacheLocation, binTempDir, nil); err != nil {`
`776`	`776`	`panic(err)`
`777`	`777`	`}`
`778`	`778`
`779`	`779`	`// Expect everything to work without cacheLocator and/or remoteFetch abilities.`
`780`	`780`	`database.cacheLocator = func() (string, bool) {`
`781`	`781`	`return "", false`
`782`	`782`	`}`
`783`		`- database.remoteFetchStrategy = func() error {`
	`783`	`+ database.remoteFetchStrategy = func(progressLogger) error {`
`784`	`784`	`return errors.New("did not work")`
`785`	`785`	`}`
`786`	`786`
Original file line number	Diff line number	Diff line change
`@@ -16,18 +16,19 @@ import (`
`16`	`16`	`)`
`17`	`17`
`18`	`18`	`// RemoteFetchStrategy provides a strategy to fetch a Postgres binary so that it is available for use.`
`19`		`-type RemoteFetchStrategy func() error`
	`19`	`+type RemoteFetchStrategy func(progressLogger) error`
`20`	`20`
`21`	`21`	`var freeBSDBinaryRepositoryURL = "https://web.sintel.com.tr/downloads/siper/pg"`
`22`	`22`
`23`	`23`	`//nolint:funlen`
`24`	`24`	`func defaultRemoteFetchStrategy(remoteFetchHost string, versionStrategy VersionStrategy, cacheLocator CacheLocator) RemoteFetchStrategy {`
`25`		`- return func() error {`
	`25`	`+ return func(logf progressLogger) error {`
`26`	`26`	`operatingSystem, architecture, version := versionStrategy()`
`27`	`27`	`cacheLocation, _ := cacheLocator()`
`28`	`28`
`29`	`29`	`if freeBSDDirectDownloadURL, ok := freeBSDBundleDownloadURL(operatingSystem, architecture); ok {`
`30`		`- if err := downloadArchiveToCache(freeBSDDirectDownloadURL, cacheLocation); err != nil {`
	`30`	`+ logProgress(logf, "downloading embedded postgres archive url=%s cache=%s", freeBSDDirectDownloadURL, cacheLocation)`
	`31`	`+ if err := downloadArchiveToCache(freeBSDDirectDownloadURL, cacheLocation, logf); err != nil {`
`31`	`32`	`return err`
`32`	`33`	`}`
`33`	`34`	`return nil`
`@@ -41,6 +42,7 @@ func defaultRemoteFetchStrategy(remoteFetchHost string, versionStrategy VersionS`
`41`	`42`	`operatingSystem,`
`42`	`43`	`architecture,`
`43`	`44`	`version)`
	`45`	`+ logProgress(logf, "downloading embedded postgres bundle url=%s cache=%s", jarDownloadURL, cacheLocation)`
`44`	`46`
`45`	`47`	`jarDownloadResponse, err := http.Get(jarDownloadURL)`
`46`	`48`	`if err != nil {`
`@@ -74,7 +76,7 @@ func defaultRemoteFetchStrategy(remoteFetchHost string, versionStrategy VersionS`
`74`	`76`	`}`
`75`	`77`	`}`
`76`	`78`
`77`		`- return decompressResponse(jarBodyBytes, jarDownloadResponse.ContentLength, cacheLocator, jarDownloadURL)`
	`79`	`+ return decompressResponse(jarBodyBytes, jarDownloadResponse.ContentLength, cacheLocator, jarDownloadURL, logf)`
`78`	`80`	`}`
`79`	`81`	`}`
`80`	`82`
`@@ -89,7 +91,7 @@ func freeBSDBundleDownloadURL(operatingSystem, architecture string) (string, boo`
`89`	`91`	`}`
`90`	`92`	`}`
`91`	`93`
`92`		`-func downloadArchiveToCache(downloadURL, cacheLocation string) error {`
	`94`	`+func downloadArchiveToCache(downloadURL, cacheLocation string, logf progressLogger) error {`
`93`	`95`	`downloadResponse, err := http.Get(downloadURL)`
`94`	`96`	`if err != nil {`
`95`	`97`	`return fmt.Errorf("unable to connect to %s", downloadURL)`
`@@ -107,6 +109,7 @@ func downloadArchiveToCache(downloadURL, cacheLocation string) error {`
`107`	`109`	`if err := os.MkdirAll(filepath.Dir(cacheLocation), 0755); err != nil {`
`108`	`110`	`return errorExtractingPostgres(err)`
`109`	`111`	`}`
	`112`	`+ logProgress(logf, "downloaded embedded postgres archive url=%s cache=%s bytes=%d", downloadURL, cacheLocation, len(archiveBytes))`
`110`	`113`	`return writeArchiveAtomically(cacheLocation, archiveBytes)`
`111`	`114`	`}`
`112`	`115`
`@@ -149,7 +152,7 @@ func closeBody(resp *http.Response) func() {`
`149`	`152`	`}`
`150`	`153`	`}`
`151`	`154`
`152`		`-func decompressResponse(bodyBytes []byte, contentLength int64, cacheLocator CacheLocator, downloadURL string) error {`
	`155`	`+func decompressResponse(bodyBytes []byte, contentLength int64, cacheLocator CacheLocator, downloadURL string, logf progressLogger) error {`
`153`	`156`	`size := contentLength`
`154`	`157`	`// if the content length is not set (i.e. chunked encoding),`
`155`	`158`	`// we need to use the length of the bodyBytes otherwise`
`@@ -170,6 +173,7 @@ func decompressResponse(bodyBytes []byte, contentLength int64, cacheLocator Cach`
`170`	`173`
`171`	`174`	`for _, file := range zipReader.File {`
`172`	`175`	`if !file.FileHeader.FileInfo().IsDir() && strings.HasSuffix(file.FileHeader.Name, ".txz") {`
	`176`	`+ logProgress(logf, "writing embedded postgres archive from bundle url=%s entry=%s cache=%s", downloadURL, file.FileHeader.Name, cacheLocation)`
`173`	`177`	`if err := decompressSingleFile(file, cacheLocation); err != nil {`
`174`	`178`	`return err`
`175`	`179`	`}`