The kopy package is the Go's common backup files operation, you can copy an entire directory or big files recursively with low CPU memory usage. This kopy package fully implemented in gokopy backup files software.

Installation

go get -u github.com/itrepablik/kopy

Usage

To copy the entire directory or a folder as an example usage using the kopy.CopyDir() method. This will not compress the directory or a folder.

package main

import (
	"fmt"
	"path/filepath"
	"time"

	"github.com/itrepablik/itrlog"
	"github.com/itrepablik/kopy"
)

func main() {
	IgnoreFilesOrFolders := []string{".txt", ".jpg", "folder_name"}

	// Example for the `kopy.CopyDir` which will copy the entire directory or a folder including its
	// sub-folders and contents.
	src, dst, msg := filepath.FromSlash("C:/a"), filepath.FromSlash("C:/b"), ""

	msg = `Starts copying the entire directory or a folder: `
	fmt.Println(msg, src)
	itrlog.Infow(msg, "src", src, "log_time", time.Now().Format(itrlog.LogTimeFormat))

	filesCopied, foldersCopied, err := kopy.CopyDir(src, dst, true, IgnoreFilesOrFolders)
	if err != nil {
		fmt.Println(err)
		itrlog.Errorw("error", "err", err, "log_time", time.Now().Format(itrlog.LogTimeFormat))
		return
	}

	// Give some info back to the user's console and the logs as well.
	msg = `Successfully copied the entire directory or a folder: `
	fmt.Println(msg, src, ", Number of Folders Copied: ", filesCopied, " Number of Files Copied: ", foldersCopied)
	itrlog.Infow(msg, "src", src, "dst", dst, "folder_copied", filesCopied, "files_copied", foldersCopied, "log_time", time.Now().Format(itrlog.LogTimeFormat))
}

To copy any single file, use the kopy.CopyFile() method. This will not compress the file.

package main

import (
	"fmt"
	"path/filepath"
	"time"

	"github.com/itrepablik/itrlog"
	"github.com/itrepablik/kopy"
)

func main() {
	// Example for kopy.CopyFile to copy single any single file only with absolute path.
	// To make directory path separator a universal, in Linux "/" and in Windows "\" to auto change
	// depends on the user's OS using the filepath.FromSlash organic Go's library.
	srcFile := filepath.FromSlash("C:/a/aaa.txt")
	dst := filepath.FromSlash("C:/b")
	msg := `Starts copying the single file:`

	fmt.Println(msg, srcFile)
	itrlog.Infow(msg, "srcFile", srcFile, "dst", dst, "log_time", time.Now().Format(itrlog.LogTimeFormat))

	dest := filepath.FromSlash(filepath.Join(args[1], filepath.Base(src)))
	
	// Starts copying the single file.
	if err := kopy.CopyFile(srcFile, dest, dst); err != nil {
		fmt.Println(err)
		itrlog.Errorw("error", "err", err, "log_time", time.Now().Format(itrlog.LogTimeFormat))
		return
	}

	// Give some info back to the user's console and the logs as well.
	msg = `Successfully copied the file:`
	fmt.Println(msg, srcFile)
	itrlog.Infow(msg, "srcFile", srcFile, "dst", dst, "log_time", time.Now().Format(itrlog.LogTimeFormat))
}

To copy only the latest modified files based on the cut-off days, use the kopy.WalkDIRModLatest() method. This will not compress the copied files.

package main

import (
	"fmt"
	"path/filepath"
	"time"

	"github.com/itrepablik/itrlog"
	"github.com/itrepablik/kopy"
)

func main() {
	NumFilesCopied := 0

	// Get the list of ignored file types or entire folder name.
	IgnoreFileTypesOrFolder := []string{".txt", ".jpg", "folder_name"}

	// To make directory path separator a universal, in Linux "/" and in Windows "\" to auto change
	// depends on the user's OS using the filepath.FromSlash organic Go's library.
	src := filepath.FromSlash("C:/a")
	dst := filepath.FromSlash("C:/b")

	msg := `Starts copying the latest files from:`
	fmt.Println(msg, src)
	itrlog.Infow(msg, "src", src, "dst", dst, "log_time", time.Now().Format(itrlog.LogTimeFormat))

	// Starts copying the latest files from.
	if err := kopy.WalkDIRModLatest(src, dst, -7, true, IgnoreFileTypesOrFolder); err != nil {
		fmt.Println(err)
		itrlog.Errorw("error", "err", err, "log_time", time.Now().Format(itrlog.LogTimeFormat))
		return
	}

	// Give some info back to the user's console and the logs as well.
	msg = `Successfully copied the latest files from:`
	fmt.Println(msg, src, " Number of Files Copied: ", NumFilesCopied)
	itrlog.Infow(msg, "src", src, "dst", dst, "copied_files", NumFilesCopied, "log_time", time.Now().Format(itrlog.LogTimeFormat))
}

To compress the entire directory or a folder, use the kopy.CompressDIR() method. It compresses the entire directory or a folder using the .tar.gz compression.

package main

import (
	"bytes"
	"fmt"
	"io"
	"os"
	"path"
	"path/filepath"
	"time"

	"github.com/itrepablik/itrlog"
	"github.com/itrepablik/kopy"
)

func main() {
	// To make directory path separator a universal, in Linux "/" and in Windows "\" to auto change
	// depends on the user's OS using the filepath.FromSlash organic Go's library.
	src := filepath.FromSlash("C:/a")
	dst := filepath.FromSlash("C:/b")
	IgnoreFilesOrFolders := []string{".txt", ".jpg", "folder_name"}

	msg := `Start compressing the directory or a folder:`
	fmt.Println(msg, src)
	itrlog.Infow(msg, "src", src, "dst", dst, "log_time", time.Now().Format(itrlog.LogTimeFormat))

	// Compose the zip filename
	fnWOext := kopy.FileNameWOExt(filepath.Base(src)) // Returns a filename without an extension.
	zipDir := fnWOext + kopy.ComFileFormat

	// To make directory path separator a universal, in Linux "/" and in Windows "\" to auto change
	// depends on the user's OS using the filepath.FromSlash organic Go's library.
	zipDest := filepath.FromSlash(path.Join(dst, zipDir))

	// Start compressing the entire directory or a folder using the tar + gzip
	var buf bytes.Buffer
	if err := kopy.CompressDIR(src, &buf, IgnoreFilesOrFolders); err != nil {
		fmt.Println(err)
		itrlog.Errorw("error", "err", err, "log_time", time.Now().Format(itrlog.LogTimeFormat))
		return
	}

	// write the .tar.gzip
	os.MkdirAll(dst, os.ModePerm) // Create the root folder first
	fileToWrite, err := os.OpenFile(zipDest, os.O_CREATE|os.O_RDWR, os.FileMode(600))
	if err != nil {
		itrlog.Errorw("error", "err", err, "log_time", time.Now().Format(itrlog.LogTimeFormat))
		panic(err)
	}
	if _, err := io.Copy(fileToWrite, &buf); err != nil {
		itrlog.Errorw("error", "err", err, "log_time", time.Now().Format(itrlog.LogTimeFormat))
		panic(err)
	}
	defer fileToWrite.Close()

	msg = `Done compressing the directory or a folder:`
	fmt.Println(msg, src)
	itrlog.Infow(msg, "dst", zipDest, "log_time", time.Now().Format(itrlog.LogTimeFormat))
}

To decompress the .tar.gz file, use the kopy.ExtractTarGz() method.

package main

import (
	"fmt"
	"os"
	"path/filepath"
	"time"

	"github.com/itrepablik/itrlog"
	"github.com/itrepablik/kopy"
)

func main() {
	// To make directory path separator a universal, in Linux "/" and in Windows "\" to auto change
	// depends on the user's OS using the filepath.FromSlash organic Go's library.
	src := filepath.FromSlash("C:/b/a.tar.gz")

	msg := `Start decompressing the folder or a directory:`
	fmt.Println(msg, src)
	itrlog.Infow(msg, "src", src, "log_time", time.Now().Format(itrlog.LogTimeFormat))

	r, err := os.Open(src)
	if err != nil {
		itrlog.Errorw("error", "err", err, "log_time", time.Now().Format(itrlog.LogTimeFormat))
		fmt.Println("error")
		return
	}
	if err := kopy.ExtractTarGz(r, src, true); err != nil {
		fmt.Println(err)
		itrlog.Errorw("error", "err", err, "log_time", time.Now().Format(itrlog.LogTimeFormat))
		return
	}

	msg = `Done decompressing the folder or a directory:`
	fmt.Println(msg, src)
	itrlog.Infow(msg, "src", src, "log_time", time.Now().Format(itrlog.LogTimeFormat))
}

To compress any single file, use the kopy.ComFiles method. It uses the zip file compression.

package main

import (
	"fmt"
	"os"
	"path"
	"path/filepath"
	"time"

	"github.com/itrepablik/itrlog"
	"github.com/itrepablik/kopy"
)

func main() {
	// Use this function to auto detect file path structure.
	src := filepath.FromSlash("C:/a/file.txt")
	dst := filepath.FromSlash("C:/b")

	// Start the process.
	msg := `Start compressing the file:`
	fmt.Println(msg, src)
	itrlog.Errorw(msg, "src", src, "dst", dst, "log_time", time.Now().Format(itrlog.LogTimeFormat))

	// Compose the zip filename
	fnWOext := kopy.FileNameWOExt(filepath.Base(src)) // Returns a filename without an extension.
	zipFileName := fnWOext + ".zip"

	// To make directory path separator a universal, in Linux "/" and in Windows "\" to auto change
	// depends on the user's OS using the filepath.FromSlash organic Go's library.
	zipDest := filepath.FromSlash(path.Join(dst, zipFileName))

	// List of Files to compressed.
	files := []string{src}

	os.MkdirAll(dst, os.ModePerm) // Create the root folder first
	if err := kopy.ComFiles(zipDest, files); err != nil {
		fmt.Println(err)
		itrlog.Errorw("error", "err", err, "log_time", time.Now().Format(itrlog.LogTimeFormat))
		return
	}

	msg = `Done compressing the file:`
	fmt.Println(msg, src)
	itrlog.Infow(msg, "src", src, "dst", zipDest, "log_time", time.Now().Format(itrlog.LogTimeFormat))
}

To decompress any single zip file, use the kopy.Unzip method.

package main

import (
	"fmt"
	"path/filepath"
	"time"

	"github.com/itrepablik/itrlog"
	"github.com/itrepablik/kopy"
)

func main() {
	// To make directory path separator a universal, in Linux "/" and in Windows "\" to auto change
	// depends on the user's OS using the filepath.FromSlash organic Go's library.
	src := filepath.FromSlash("C:/b/file.zip")

	msg := `Start decompressing the file:`
	fmt.Println(msg, src)
	itrlog.Errorw(msg, "src", src, "log_time", time.Now().Format(itrlog.LogTimeFormat))

	if err := kopy.Unzip(src, true); err != nil {
		fmt.Println(err)
		itrlog.Errorw("error", "err", err, "log_time", time.Now().Format(itrlog.LogTimeFormat))
		return
	}

	msg = `Done decompressing the file:`
	fmt.Println(msg, src)
	itrlog.Errorw(msg, "src", src, "log_time", time.Now().Format(itrlog.LogTimeFormat))
}

Subscribe to Maharlikans Code Youtube Channel:

Please consider subscribing to my Youtube Channel to recognize my work on this package. Thank you for your support! https://www.youtube.com/channel/UCdAVUmldU9Jn2VntuQChHqQ/

License

Code is distributed under MIT license, feel free to use it in your proprietary projects as well.