196 lines
7.5 KiB
Go
196 lines
7.5 KiB
Go
package main
|
|
|
|
import (
|
|
"archive/tar"
|
|
"encoding/json"
|
|
"github.com/pkg/browser"
|
|
"github.com/rs/zerolog"
|
|
"github.com/rs/zerolog/log"
|
|
"io"
|
|
"io/ioutil"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
// Create config type to store action type and data
|
|
type Config struct {
|
|
ActionType string
|
|
ActionData string
|
|
}
|
|
|
|
// Instantiate and return a new Config struct
|
|
func NewConfig(actionType string, actionData string) *Config {
|
|
return &Config{ActionType: actionType, ActionData: actionData}
|
|
}
|
|
|
|
// Create config file
|
|
func (config *Config) CreateFile(dir string) {
|
|
// Use ConsoleWriter logger
|
|
log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr}).Hook(FatalHook{})
|
|
// Create config file at given directory
|
|
configFile, err := os.Create(dir + "/config.json")
|
|
if err != nil { log.Fatal().Err(err).Msg("Error creating config file") }
|
|
// Close config file at the end of this function
|
|
defer configFile.Close()
|
|
// Marshal given Config struct into a []byte
|
|
jsonData, err := json.Marshal(config)
|
|
if err != nil { log.Fatal().Err(err).Msg("Error encoding JSON") }
|
|
// Write []byte to previously created config file
|
|
bytesWritten, err := configFile.Write(jsonData)
|
|
if err != nil { log.Fatal().Err(err).Msg("Error writing JSON to file") }
|
|
// Log bytes written
|
|
log.Info().Str("file", "config.json").Msg("Wrote " + strconv.Itoa(bytesWritten) + " bytes")
|
|
}
|
|
|
|
// Collect all required files into given directory
|
|
func (config *Config) CollectFiles(dir string) {
|
|
// Use ConsoleWriter logger
|
|
log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr}).Hook(FatalHook{})
|
|
// If action type is file
|
|
if config.ActionType == "file" {
|
|
// Open file path in config.ActionData
|
|
src, err := os.Open(config.ActionData)
|
|
if err != nil { log.Fatal().Err(err).Msg("Error opening file from config") }
|
|
// Close source file at the end of this function
|
|
defer src.Close()
|
|
// Create new file with the same name at given directory
|
|
dst, err := os.Create(dir + "/" + filepath.Base(config.ActionData))
|
|
if err != nil { log.Fatal().Err(err).Msg("Error creating file") }
|
|
// Close new file at the end of this function
|
|
defer dst.Close()
|
|
// Copy data from source file to destination file
|
|
_, err = io.Copy(dst, src)
|
|
if err != nil { log.Fatal().Err(err).Msg("Error copying data to file") }
|
|
// Replace file path in config.ActionData with file name
|
|
config.ActionData = filepath.Base(config.ActionData)
|
|
} else if config.ActionType == "dir" {
|
|
// Create tar archive
|
|
tarFile, err := os.Create(dir + "/" + filepath.Base(config.ActionData) + ".tar")
|
|
if err != nil { log.Fatal().Err(err).Msg("Error creating file") }
|
|
// Close tar file at the end of this function
|
|
defer tarFile.Close()
|
|
// Create writer for tar archive
|
|
tarArchiver := tar.NewWriter(tarFile)
|
|
// Close archiver at the end of this function
|
|
defer tarArchiver.Close()
|
|
// Walk given directory
|
|
err = filepath.Walk(config.ActionData, func(path string, info os.FileInfo, err error) error {
|
|
// Return if error walking
|
|
if err != nil { return err }
|
|
// Skip if file is not normal mode
|
|
if !info.Mode().IsRegular() { return nil }
|
|
// Create tar header for file
|
|
header, err := tar.FileInfoHeader(info, info.Name())
|
|
if err != nil { return err }
|
|
// Change header name to reflect decompressed filepath
|
|
header.Name = strings.TrimPrefix(strings.ReplaceAll(path, config.ActionData, ""), string(filepath.Separator))
|
|
// Write header to archive
|
|
if err := tarArchiver.WriteHeader(header); err != nil { return err }
|
|
// Open source file
|
|
src, err := os.Open(path)
|
|
if err != nil { return err }
|
|
// Close source file at the end of this function
|
|
defer src.Close()
|
|
// Copy source bytes to tar archive
|
|
if _, err := io.Copy(tarArchiver, src); err != nil { return err }
|
|
// Return at the end of the function
|
|
return nil
|
|
})
|
|
if err != nil { log.Fatal().Err(err).Msg("Error creating tar archive") }
|
|
// Set config data to base path for receiver
|
|
config.ActionData = filepath.Base(config.ActionData)
|
|
}
|
|
}
|
|
|
|
// Read config file at given file path
|
|
func (config *Config) ReadFile(filePath string) {
|
|
// Use ConsoleWriter logger
|
|
log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr}).Hook(FatalHook{})
|
|
// Read file at filePath
|
|
fileData, err := ioutil.ReadFile(filePath)
|
|
if err != nil { log.Fatal().Err(err).Msg("Error reading config file") }
|
|
// Unmarshal data from JSON into config struct
|
|
err = json.Unmarshal(fileData, config)
|
|
if err != nil { log.Fatal().Err(err).Msg("Error decoding JSON") }
|
|
}
|
|
|
|
// Execute action specified in config
|
|
func (config *Config) ExecuteAction(srcDir string) {
|
|
// Get user's home directory
|
|
homeDir, err := os.UserHomeDir()
|
|
if err != nil { log.Fatal().Err(err).Msg("Error getting home directory") }
|
|
// Use ConsoleWriter logger
|
|
log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr}).Hook(FatalHook{})
|
|
// If action is file
|
|
if config.ActionType == "file" {
|
|
// Open file from config at given directory
|
|
src, err := os.Open(srcDir + "/" + config.ActionData)
|
|
if err != nil { log.Fatal().Err(err).Msg("Error reading file from config") }
|
|
// Close source file at the end of this function
|
|
defer src.Close()
|
|
// Create file in user's Downloads directory
|
|
dst, err := os.Create(homeDir + "/Downloads/" + config.ActionData)
|
|
if err != nil { log.Fatal().Err(err).Msg("Error creating file") }
|
|
// Close destination file at the end of this function
|
|
defer dst.Close()
|
|
// Copy data from source file to destination file
|
|
_, err = io.Copy(dst, src)
|
|
if err != nil { log.Fatal().Err(err).Msg("Error copying data to file") }
|
|
// If action is url
|
|
} else if config.ActionType == "url" {
|
|
// Attempt to open URL in browser
|
|
err := browser.OpenURL(config.ActionData)
|
|
if err != nil { log.Fatal().Err(err).Msg("Error opening browser") }
|
|
// If action is dir
|
|
} else if config.ActionType == "dir" {
|
|
// Set destination directory to ~/Downloads/{dir name}
|
|
dstDir := homeDir + "/Downloads/" + config.ActionData
|
|
// Try to create destination directory
|
|
err := os.Mkdir(dstDir, 0755)
|
|
if err != nil { log.Fatal().Err(err).Msg("Error creating directory") }
|
|
// Try to open tar archive file
|
|
tarFile, err := os.Open(srcDir + "/" + config.ActionData + ".tar")
|
|
if err != nil { log.Fatal().Err(err).Msg("Error opening tar archive") }
|
|
// Close tar archive file at the end of this function
|
|
defer tarFile.Close()
|
|
// Create tar reader to unarchive tar archive
|
|
tarUnarchiver := tar.NewReader(tarFile)
|
|
// Loop to recursively unarchive tar file
|
|
unarchiveLoop: for {
|
|
// Jump to next header in tar archive
|
|
header, err := tarUnarchiver.Next()
|
|
switch {
|
|
// If EOF
|
|
case err == io.EOF:
|
|
// break loop
|
|
break unarchiveLoop
|
|
case err != nil:
|
|
log.Fatal().Err(err).Msg("Error unarchiving tar archive")
|
|
// If nil header
|
|
case header == nil:
|
|
// Skip
|
|
continue
|
|
}
|
|
// Set target path to header name in destination dir
|
|
targetPath := filepath.Join(dstDir, header.Name)
|
|
switch header.Typeflag {
|
|
// If regular file
|
|
case tar.TypeReg:
|
|
// Try to create containing folder ignoring errors
|
|
_ = os.MkdirAll(strings.TrimSuffix(targetPath, filepath.Base(targetPath)), 0755)
|
|
// Create file with mode contained in header at target path
|
|
dstFile, err := os.OpenFile(targetPath, os.O_CREATE|os.O_RDWR, os.FileMode(header.Mode))
|
|
if err != nil { log.Fatal().Err(err).Msg("Error creating file during unarchiving") }
|
|
// Copy data from tar archive into file
|
|
_, err = io.Copy(dstFile, tarUnarchiver)
|
|
if err != nil { log.Fatal().Err(err).Msg("Error copying data to file") }
|
|
}
|
|
}
|
|
// Catchall
|
|
} else {
|
|
// Log unknown action type
|
|
log.Fatal().Msg("Unknown action type " + config.ActionType)
|
|
}
|
|
} |