Merge bca194d into 21c2df6

backup_test.go

@@ -191,6 +191,7 @@ func TestBackupForget(t *testing.T) {
 	cmd = ForgetRepoDetail(env, pwd, 1, 1, 1)
 	job = CreateJobFromCommand(cmd, "forget")
 	err = job.RunJob(true)
+	assert.NoError(t, err)
 
 	cmd = ListRepo(env, pwd)
 	job = CreateJobFromCommand(cmd, "list")

config.go

@@ -141,7 +141,6 @@ func GetResticConfig(config *vault.Config, token string, path string) (*ResticCo
 	data, err := getDataFromSecret(config, token, "restic/data/"+path)
 	if err != nil {
 		return nil, err
-
 	}
 
 	var conf ResticConfig

config_test.go

@@ -106,7 +106,11 @@ func TestConfigGetResticConfig(t *testing.T) {
 	require.NoError(t, err)
 	assert.False(t, seal, ERROR_VAULT_SEALED)
 
-	conf, err := GetResticConfig(testconfig.config, testconfig.token, testconfig.resticpath)
+	conf, err := GetResticConfig(testconfig.config, testconfig.token, "forbidden")
+	assert.Error(t, err)
+	assert.Nil(t, conf)
+
+	conf, err = GetResticConfig(testconfig.config, testconfig.token, testconfig.resticpath)
 	assert.NoError(t, err)
 	assert.NotNil(t, conf.Path)
 	assert.NotNil(t, conf.Password)

git.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 
 	git "github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/config"
 	"github.com/go-git/go-git/v5/plumbing/transport/http"
 )
 
@@ -45,6 +46,24 @@ func GitClone(repo string, dir string, home string, personal string) error {
 	return nil
 }
 
+func GitCreateRemote(dir string, home string, repoUrl string) error {
+	path := strings.ReplaceAll(dir, HOME, home)
+	r, err := git.PlainOpen(path)
+	if err != nil {
+		return err
+	}
+	_, err = r.Remote(GIT_REMOTE_NAME)
+	if err != nil && err == git.ErrRemoteNotFound {
+		log.Println("Adding remote: ", GIT_REMOTE_NAME)
+		_, err = r.CreateRemote(&config.RemoteConfig{
+			Name: GIT_REMOTE_NAME,
+			URLs: []string{repoUrl},
+		})
+		return err
+	}
+	return err
+}
+
 func GitPull(dir string, home string, personal string) error {
 	path := strings.ReplaceAll(dir, HOME, home)
 	log.Println("Pulling from: ", path)
@@ -59,13 +78,17 @@ func GitPull(dir string, home string, personal string) error {
 		return err
 	}
 
-	var pullOptions git.PullOptions
+	pullOptions := git.PullOptions{
+		RemoteName: GIT_REMOTE_NAME,
+	}
+
 	if personal != "" {
 		pullOptions.Auth = &http.BasicAuth{
 			Username: "abc123", // yes, this can be anything except an empty string
 			Password: personal,
 		}
 	}
+
 	// Pull the latest changes from the origin remote and merge into the current branch
 	err = w.Pull(&pullOptions)
 	if err != nil && err != git.NoErrAlreadyUpToDate {

git_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -23,10 +24,13 @@ func TestGitClone(t *testing.T) {
 	assert.NoError(t, err)
 	assert.DirExists(t, test_folder)
 
+	_, err = git.PlainOpen(test_folder)
+	assert.NoError(t, err)
+
 	// Second Clone for test if repo exists error is ignored
 	err = GitClone(GIT_TEST_REPO, GIT_TEST_FOLDER, pwd, "test")
 	require.Error(t, err)
-	assert.EqualError(t, err, git.ErrRepositoryAlreadyExists.Error())
+	assert.Error(t, git.ErrRepositoryAlreadyExists, err)
 }
 
 func TestGitPull(t *testing.T) {
@@ -37,10 +41,73 @@ func TestGitPull(t *testing.T) {
 	test_folder := strings.ReplaceAll(GIT_TEST_FOLDER, HOME, pwd)
 	require.NoDirExists(t, test_folder)
 
-	err = GitClone(GIT_TEST_REPO, GIT_TEST_FOLDER, pwd, "")
+	r, err := git.PlainClone(test_folder, false, &git.CloneOptions{
+		URL: GIT_TEST_REPO,
+	})
+
+	require.NoError(t, err)
+	require.DirExists(t, test_folder)
+
+	ref, err := r.Head()
+	require.NoError(t, err)
+	head := ref.Hash().String()
+
+	remote, err := r.Remote(GIT_REMOTE_NAME)
+	assert.Error(t, git.ErrRemoteNotFound, err)
+	assert.Nil(t, remote)
+
+	w, err := r.Worktree()
 	assert.NoError(t, err)
-	assert.DirExists(t, test_folder)
+	assert.NotNil(t, w)
+
+	err = w.Checkout(&git.CheckoutOptions{
+		Hash: plumbing.NewHash(GIT_TEST_COMMIT),
+	})
+	assert.NoError(t, err)
+	ref, err = r.Head()
+	assert.NoError(t, err)
+	assert.Equal(t, GIT_TEST_COMMIT, ref.Hash().String())
 
 	err = GitPull(GIT_TEST_FOLDER, pwd, "")
+	assert.Error(t, git.ErrRemoteNotFound, err)
+	err = GitCreateRemote(GIT_TEST_FOLDER, pwd, GIT_TEST_REPO)
+	assert.NoError(t, err)
+
+	err = GitPull(GIT_TEST_FOLDER, pwd, "")
+	assert.NoError(t, err)
+	remote, err = r.Remote(GIT_REMOTE_NAME)
+	assert.NoError(t, err)
+	assert.NotNil(t, remote)
+
+	ref, err = r.Head()
+	assert.NoError(t, err)
+	assert.Equal(t, head, ref.Hash().String())
+}
+
+func TestGitCreateRemote(t *testing.T) {
+	fmt.Println("running: TestGitCreateRemote")
+	t.Cleanup(clear)
+
+	t.Cleanup(clear)
+	pwd, err := os.Getwd()
+	require.NoError(t, err)
+	test_folder := strings.ReplaceAll(GIT_TEST_FOLDER, HOME, pwd)
+	require.NoDirExists(t, test_folder)
+
+	r, err := git.PlainClone(test_folder, false, &git.CloneOptions{
+		URL: GIT_TEST_REPO,
+	})
+	require.NoError(t, err)
+	require.DirExists(t, test_folder)
+
+	remote, err := r.Remote(GIT_REMOTE_NAME)
+	assert.Error(t, git.ErrRemoteNotFound, err)
+	assert.Nil(t, remote)
+
+	err = GitCreateRemote(GIT_TEST_FOLDER, pwd, GIT_TEST_REPO)
+	assert.NoError(t, err)
+
+	remote, err = r.Remote(GIT_REMOTE_NAME)
 	assert.NoError(t, err)
+	assert.NotNil(t, remote)
 }

main_test.go

@@ -271,7 +271,11 @@ func TestMainSendRequest(t *testing.T) {
 		Addr:    MAIN_TEST_ADDRESS,
 		Handler: router,
 	}
-	go server.ListenAndServe()
+	go func() {
+		err := server.ListenAndServe()
+		assert.Equal(t, http.ErrServerClosed, err)
+	}()
+
 	time.Sleep(100 * time.Millisecond)
 	AgentConfiguration.Address = MAIN_TEST_ADDRESS
 

restrouter.go

@@ -260,6 +260,8 @@ func postBackup(c *gin.Context) {
 		return
 	}
 
+	log.Println("config:", config)
+
 	var cmd *exec.Cmd
 	switch msg.Mode {
 	case "init":
@@ -380,7 +382,12 @@ func postGit(c *gin.Context) {
 			}, msg.Mode+" "+v.Name)
 		case "pull":
 			job = CreateJobFromFunction(func() error {
-				return GitPull(v.Directory, config.Agent.HomeFolder, v.PersonalToken)
+				err := GitCreateRemote(v.Directory, config.Agent.HomeFolder, v.Rep)
+				if err != nil {
+					return err
+				} else {
+					return GitPull(v.Directory, config.Agent.HomeFolder, v.PersonalToken)
+				}
 			}, msg.Mode+" "+v.Name)
 		default:
 			returnErr(errors.New("Not supported Mode: "+msg.Mode), ERROR_GIT, c)

restrouter_test.go

@@ -179,8 +179,32 @@ func TestRestPostBackup(t *testing.T) {
 	assert.NoError(t, err)
 }
 
+func TestRestForbidden(t *testing.T) {
+	fmt.Println("running: TestRestPostBackup")
+	t.Cleanup(clear)
+	setupRestrouterTest(t)
+	server, fun := RunRestServer(MAIN_TEST_ADDRESS)
+
+	go fun()
+	time.Sleep(1 * time.Millisecond)
+
+	msg := BackupMessage{
+		Mode:        "backup",
+		Test:        true,
+		Run:         true,
+		Debug:       true,
+		PrintOutput: true,
+		Token:       "randomtoken",
+	}
+	sendingPost(t, REST_TEST_BACKUP, http.StatusOK, msg)
+
+	err := server.Shutdown(context.Background())
+	assert.NoError(t, err)
+}
+
 func TestRestPostMount(t *testing.T) {
 	fmt.Println("running: TestRestPostMount")
+	t.Cleanup(clear)
 	setupRestrouterTest(t)
 	server, fun := RunRestServer(MAIN_TEST_ADDRESS)
 	mountMsg := MountMessage{

statics.go

@@ -7,6 +7,9 @@ const (
 	RESTIC_ACCESS_KEY = "AWS_ACCESS_KEY_ID="
 	RESTIC_SECRET_KEY = "AWS_SECRET_ACCESS_KEY="
 
+	// Git Contstatns
+	GIT_REMOTE_NAME = "agent_remote"
+
 	// Store Constants
 	STORE_TOKEN       = "token"
 	STORE_TIMESTAMP   = "timestamp"
@@ -52,13 +55,11 @@ const (
 	ERROR_MODE         = "Backup Mode:"
 	ERROR_GIT          = "GIT Mode:"
 	ERROR_STATUS       = "GetStatus:"
-	ERROR_LOG          = "GetLogs:"
 	ERROR_ISSEALED     = "IsSealed:"
 	ERROR_UNSEAL       = "Unseal:"
 	ERROR_SEAL         = "Seal:"
 	ERROR_RUNBACKUP    = "RunBackupJob:"
 	ERROR_RUNMOUNT     = "RunMountJob:"
-	ERROR_ENQUEUE      = "Enqueue:"
 	ERROR_CONFIG       = "GetConfigFromVault:"
 	ERROR_BINDING      = "BindJSON:"
 	ERROR_PUT_TOKEN    = "PutToken:"
@@ -88,6 +89,7 @@ const (
 	GIT_TEST_REPO         = "https://github.com/azak-azkaran/reverse-link"
 	GIT_TEST_FOLDER_VIMRC = "~/test/vimrc"
 	GIT_TEST_REPO_VIMRC   = "https://github.com/amix/vimrc.git"
+	GIT_TEST_COMMIT       = "dd7e3c0b1ec7bbde6034d8cb2739bcd67f2530a4"
 
 	VAULT_TEST_PASSWORD            = "hallo"
 	VAULT_TEST_TOKEN               = "superrandompasswordtoken"

vault.go

@@ -82,7 +82,7 @@ func getDataFromSecret(config *vault.Config, token string, path string) (map[str
 		return nil, err
 	}
 
-	if secret == nil {
+	if secret == nil || secret.Data == nil {
 		return nil, errors.New(ERROR_VAULT_NO_SECRET)
 	}
 

vault_gin_test.go

@@ -21,6 +21,7 @@ var multipleKey bool = false
 
 var Progress = 0
 var Hostname string
+var ResticPath = "resticpath"
 
 func StartServer(t *testing.T, address string) {
 	if running {
@@ -63,23 +64,8 @@ func createHandler() http.Handler {
 		sealStatus = true
 		c.JSON(http.StatusOK, nil)
 	})
-	r.GET("/v1/restic/data/resticpath", func(c *gin.Context) {
-		log.Println("MOCK-Server: called resticpath")
-		var msg vault.Secret
-		data := make(map[string]interface{})
-		secret := make(map[string]string)
-		secret["path"] = "~/"
-		secret["repo"] = VAULT_TEST_BACKUP_PATH
-		secret["pw"] = VAULT_TEST_PASSWORD
-		secret["exclude"] = VAULT_TEST_BACKUP_EXCLUDE_FILE
-		secret["access_key"] = VAULT_TEST_BACKUP_ACCESS_KEY
-		secret["secret_key"] = VAULT_TEST_BACKUP_SECRET_KEY
-		data["data"] = secret
-		msg.Data = data
-		c.JSON(http.StatusOK, msg)
-	})
-	//r.GET("/v1/config/"+Hostname, config)
-	//r.GET("/v1/config/configpath", config)
+	r.GET("/v1/restic/data/resticpath", test_restic)
+	r.GET("/v1/restic/data/forbidden", test_forbidden)
 	r.GET("/v1/config/:name", func(c *gin.Context) {
 		name := c.Param("name")
 
@@ -124,7 +110,7 @@ func test_config(c *gin.Context) {
 		log.Println(err)
 	}
 
-	data["restic"] = "resticpath"
+	data["restic"] = ResticPath
 	data["gocryptfs"] = VAULT_TEST_CONFIGPATH
 	data["git"] = "gitpath,vimrc"
 	data["home"] = pwd
@@ -195,3 +181,29 @@ func test_unseal(c *gin.Context) {
 
 	c.JSON(http.StatusOK, msg)
 }
+
+func test_forbidden(c *gin.Context) {
+	log.Println("MOCK-Server: called forbidden")
+	var msg vault.Secret
+	data := make(map[string]interface{})
+	secret := make(map[string]string)
+	data["data"] = secret
+	msg.Data = data
+	c.JSON(http.StatusForbidden, msg)
+}
+
+func test_restic(c *gin.Context) {
+	log.Println("MOCK-Server: called resticpath")
+	var msg vault.Secret
+	data := make(map[string]interface{})
+	secret := make(map[string]string)
+	secret["path"] = "~/"
+	secret["repo"] = VAULT_TEST_BACKUP_PATH
+	secret["pw"] = VAULT_TEST_PASSWORD
+	secret["exclude"] = VAULT_TEST_BACKUP_EXCLUDE_FILE
+	secret["access_key"] = VAULT_TEST_BACKUP_ACCESS_KEY
+	secret["secret_key"] = VAULT_TEST_BACKUP_SECRET_KEY
+	data["data"] = secret
+	msg.Data = data
+	c.JSON(http.StatusOK, msg)
+}