use tar to transfer configuration files to the remote server

Author: creativeprojects

config/config.go

@@ -709,6 +709,8 @@ func (c *Config) GetRemote(remoteName string) (*Remote, error) {
 	remote := NewRemote(c, remoteName)
 	err := c.unmarshalKey(c.flatKey(constants.SectionConfigurationRemotes, remoteName), remote)
 
+	rootPath := filepath.Dir(c.GetConfigFile())
+	remote.SetRootPath(rootPath)
 	return remote, err
 }
 

config/remote .go

@@ -18,3 +18,10 @@ func NewRemote(config *Config, name string) *Remote {
 	}
 	return remote
 }
+
+// SetRootPath changes the path of all the relative paths and files in the configuration
+func (r *Remote) SetRootPath(rootPath string) {
+	for i := range r.SendFiles {
+		r.SendFiles[i] = fixPath(r.SendFiles[i], expandEnv, absolutePrefix(rootPath))
+	}
+}

send.go

@@ -1,9 +1,13 @@
 package main
 
 import (
+	"archive/tar"
 	"fmt"
 	"io"
+	"net/http"
+	"os"
 
+	"github.com/creativeprojects/clog"
 	"github.com/creativeprojects/resticprofile/ssh"
 )
 
@@ -15,16 +19,58 @@ func sendProfileCommand(w io.Writer, cmdCtx commandContext) error {
 	if err != nil {
 		return err
 	}
+	// send the files to the remote using tar
+	handler := http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
+		writer := tar.NewWriter(resp)
+		defer writer.Close()
+
+		for _, filename := range remote.SendFiles {
+			fileInfo, err := os.Stat(filename)
+			if err != nil {
+				clog.Errorf("unable to stat file %s: %v", filename, err)
+				continue
+			}
+			fileHeader, err := tar.FileInfoHeader(fileInfo, "")
+			if err != nil {
+				clog.Errorf("unable to create tar header for file %s: %v", filename, err)
+				continue
+			}
+			err = writer.WriteHeader(fileHeader)
+			if err != nil {
+				clog.Errorf("unable to write tar header for file %s: %v", filename, err)
+				break
+			}
+			file, err := os.Open(filename)
+			if err != nil {
+				clog.Errorf("unable to open file %s: %v", filename, err)
+				continue
+			}
+			defer file.Close()
+
+			written, err := io.Copy(writer, file)
+			if err != nil {
+				clog.Errorf("unable to write file %s: %v", filename, err)
+				break
+			}
+			if written != fileInfo.Size() {
+				clog.Errorf("file %s written %d bytes, expected %d", filename, written, fileInfo.Size())
+				break
+			}
+			clog.Debugf("file %s written %d bytes", filename, written)
+		}
+	})
 	cnx := ssh.NewSSH(ssh.Config{
 		Host:           remote.Host,
 		Username:       remote.Username,
 		PrivateKeyPath: remote.PrivateKeyPath,
 		KnownHostsPath: remote.KnownHostsPath,
+		Handler:        handler,
 	})
+	defer cnx.Close()
+
 	err = cnx.Connect()
 	if err != nil {
 		return err
 	}
-	defer cnx.Close()
 	return nil
 }

ssh/config.go

@@ -2,6 +2,7 @@ package ssh
 
 import (
 	"fmt"
+	"net/http"
 	"os"
 	"path/filepath"
 	"strings"
@@ -12,6 +13,7 @@ type Config struct {
 	Username       string
 	PrivateKeyPath string
 	KnownHostsPath string
+	Handler        http.Handler
 }
 
 func (c *Config) Validate() error {

ssh/ssh.go

@@ -2,11 +2,13 @@ package ssh
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"log"
 	"net"
 	"net/http"
 	"os"
+	"time"
 
 	"github.com/creativeprojects/clog"
 	"golang.org/x/crypto/ssh"
@@ -20,6 +22,7 @@ type SSH struct {
 	port   int
 	client *ssh.Client
 	tunnel net.Listener
+	server *http.Server
 }
 
 func NewSSH(config Config) *SSH {
@@ -71,10 +74,14 @@ func (s *SSH) Connect() error {
 	}
 
 	go func() {
+		s.server = &http.Server{
+			Handler: s.config.Handler,
+		}
 		// Serve HTTP with your SSH server acting as a reverse proxy.
-		http.Serve(s.tunnel, http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
-			fmt.Fprintf(resp, "Hello world!\n")
-		}))
+		err := s.server.Serve(s.tunnel)
+		if err != nil && err != http.ErrServerClosed {
+			clog.Warningf("unable to serve http: %s", err)
+		}
 	}()
 
 	// Each ClientConn can support multiple interactive sessions,
@@ -103,6 +110,14 @@ func (s *SSH) Close() {
 			clog.Warningf("unable to close tunnel: %s", err)
 		}
 	}
+	if s.server != nil {
+		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+		defer cancel()
+		err := s.server.Shutdown(ctx)
+		if err != nil {
+			clog.Warningf("unable to close http server: %s", err)
+		}
+	}
 	if s.client != nil {
 		err := s.client.Close()
 		if err != nil {