pico

chore: rsync test open rss

created pr with 47.1 on 2025-02-21T21:07:49Z · by c8ef7d19

added 47.2 on 2025-02-21T21:21:15Z · by c8ef7d19


                      1:  0306c3f < -:  ------- chore: rsync test


                      2:  971b354 ! 1:  745b513 chore: add `rsync --delete` test

added 47.3 on 2025-02-21T21:21:56Z · by c8ef7d19


                      1:  745b513 ! 1:  76a6734 chore: add `rsync --delete` test

added 47.4 on 2025-02-21T21:22:20Z · by c8ef7d19


                      1:  76a6734 ! 1:  57bb60c chore: add `rsync --delete` test

added 47.5 on 2025-02-22T02:12:03Z · by c8ef7d19


                      1:  57bb60c = 1:  57bb60c chore: add `rsync --delete` test


                      -:  ------- > 2:  5c8d929 chore: test is failing on `--delete`

changed status to accepted on 2025-03-13T14:53:20Z · by c8ef7d19

cmds

checkout latest patchset:

ssh pr.pico.sh print 47 | git am -3

checkout any patchset in a patch request:

ssh pr.pico.sh print 47.[rev] | git am -3

add changes to patch request:

git format-patch main --stdout | ssh pr.pico.sh pr add 47

set PR to open (enables RSS notifications):

ssh pr.pico.sh pr open 47

set PR to draft (stops RSS notifications):

ssh pr.pico.sh pr draft 47

Patchset `47.2` on 2025-02-21T21:21:15Z · commit 745b513

→ chore: add `rsync --delete` test

Eric Bower 2025-02-17T15:36:03Z

chore: add `rsync --delete` test

Eric Bower 2025-02-17T15:36:03Z

I can't figure out how to format the `exec.Command` for rsync with `-e`
flag

Current error:

```
[rsync -rv -e "ssh -p 2222 -o IdentitiesOnly=yes -i /tmp/rsync-3246995037/id_ed25519 -o StrictHostKeyChecking=no" /tmp/rsync-3246995037/ localhost:/test]
rsync: [sender] Failed to exec ssh -p 2222 -o IdentitiesOnly=yes -i /tmp/rsync-3246995037/id_ed25519 -o StrictHostKeyChecking=no: No such file or directory (2)
rsync error: error in IPC code (code 14) at pipe.c(85) [sender=3.4.0]
rsync: connection unexpectedly closed (0 bytes received so far) [sender]
rsync error: error in IPC code (code 14) at io.c(232) [sender=3.4.0]
 exit status 14
--- FAIL: TestSshServerRsync (0.10s)
    ssh_test.go:152: exit status 14
```

Semantic diff summary

4 added, 4 modified, 0 signature changed, 1 removed across 2 analyzed files

pgs/ssh_test.go

chunk lines 3-16 modified
function_declaration TestSshServerSftp added
function_declaration TestSshServer removed
type_declaration UserSSH modified
function_declaration TestSshServerRsync added
function_declaration createTmpFile added
function_declaration WriteFilesWithRsync added

shared/ssh.go

chunk lines 1-7 modified
function_declaration NewSshAuthHandler modified

+153 -5 pgs/ssh_test.go #

......@@ -3,9 +3,14 @@ package pgs
import (
	"crypto/ed25519"
	"crypto/rand"
	"crypto/x509"
	"encoding/pem"
	"fmt"
	"io"
	"log/slog"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"testing"
	"time"

......@@ -18,7 +23,7 @@ import (
	"golang.org/x/crypto/ssh"
)

func TestSshServer(t *testing.T) {
func TestSshServerSftp(t *testing.T) {
	logger := slog.Default()
	dbpool := pgsdb.NewDBMemory(logger)
	// setup test data

......@@ -57,9 +62,142 @@ func TestSshServer(t *testing.T) {
	done <- nil
}

func TestSshServerRsync(t *testing.T) {
	logger := slog.Default()
	dbpool := pgsdb.NewDBMemory(logger)
	// setup test data
	dbpool.SetupTestData()
	st, err := storage.NewStorageMemory(map[string]map[string]string{})
	if err != nil {
		panic(err)
	}
	cfg := NewPgsConfig(logger, dbpool, st)
	done := make(chan error)
	go StartSshServer(cfg, done)
	// Hack to wait for startup
	time.Sleep(time.Millisecond * 100)

	user := GenerateUser()
	key := utils.KeyForKeyText(user.signer.PublicKey())
	// add user's pubkey to the default test account
	dbpool.Pubkeys = append(dbpool.Pubkeys, &db.PublicKey{
		ID:     "nice-pubkey",
		UserID: dbpool.Users[0].ID,
		Key:    key,
	})

	conn, err := user.NewClient()
	if err != nil {
		t.Error(err)
		return
	}
	defer conn.Close()

	// open an SFTP session over an existing ssh connection.
	client, err := sftp.NewClient(conn)
	if err != nil {
		cfg.Logger.Error("could not create sftp client", "err", err)
		panic(err)
	}
	defer client.Close()

	name, err := os.MkdirTemp("", "rsync-")
	if err != nil {
		panic(err)
	}

	// remove the temporary directory at the end of the program
	defer os.RemoveAll(name)

	block := &pem.Block{
		Type:  "PRIVATE KEY",
		Bytes: user.privateKey,
	}
	keyFile := filepath.Join(name, "id_ed25519")
	err = os.WriteFile(
		keyFile,
		pem.EncodeToMemory(block), 0600,
	)

	index := "<!doctype html><html><body>index</body></html>"
	err = os.WriteFile(
		filepath.Join(name, "index.html"),
		[]byte(index), 0666,
	)

	about := "<!doctype html><html><body>about</body></html>"
	aboutFile := filepath.Join(name, "about.html")
	err = os.WriteFile(
		aboutFile,
		[]byte(about), 0666,
	)

	contact := "<!doctype html><html><body>contact</body></html>"
	err = os.WriteFile(
		filepath.Join(name, "contact.html"),
		[]byte(contact), 0666,
	)

	eCmd := fmt.Sprintf(
		`"ssh -p 2222 -o IdentitiesOnly=yes -i %s -o StrictHostKeyChecking=no"`,
		keyFile,
	)

	// copy files
	cmd := exec.Command("rsync", "-rv", "-e", eCmd, name+"/", "localhost:/test")
	fmt.Println(cmd.Args)
	result, err := cmd.CombinedOutput()
	if err != nil {
		fmt.Println(string(result), err)
		t.Error(err)
		return
	}

	// check it's there
	fi, err := client.Lstat("about.html")
	if err != nil {
		cfg.Logger.Error("could not get stat for file", "err", err)
		t.Error("about.html not found")
		return
	}
	if fi.Size() != 0 {
		cfg.Logger.Error("about.html wrong size", "size", fi.Size())
		t.Error("about.html wrong size")
		return
	}

	// remove about file
	os.Remove(aboutFile)

	// copy files with delete
	delCmd := exec.Command("rsync", "-rv", "--delete", "-e", eCmd, name+"/", "localhost:/test")
	err = delCmd.Run()
	if err != nil {
		t.Error(err)
		return
	}

	done <- nil
}

func createTmpFile(name, contents, ext string) *os.File {
	file, err := os.CreateTemp("tmp", fmt.Sprintf("%s-*.%s", name, ext))
	if err != nil {
		panic(err)
	}

	data := []byte(contents)
	if _, err := file.Write(data); err != nil {
		panic(err)
	}

	return file
}

type UserSSH struct {
	username string
	signer   ssh.Signer
	username   string
	signer     ssh.Signer
	privateKey []byte
}

func NewUserSSH(username string, signer ssh.Signer) *UserSSH {

......@@ -146,17 +284,27 @@ func GenerateUser() UserSSH {
		panic(err)
	}

	b, err := x509.MarshalPKCS8PrivateKey(userKey)
	if err != nil {
		panic(err)
	}

	userSigner, err := ssh.NewSignerFromKey(userKey)
	if err != nil {
		panic(err)
	}

	return UserSSH{
		username: "testuser",
		signer:   userSigner,
		username:   "testuser",
		signer:     userSigner,
		privateKey: b,
	}
}

func WriteFilesWithRsync(cfg *PgsConfig, conn *ssh.Client, files []string) (*os.FileInfo, error) {
	return nil, nil
}

func WriteFileWithSftp(cfg *PgsConfig, conn *ssh.Client) (*os.FileInfo, error) {
	// open an SFTP session over an existing ssh connection.
	client, err := sftp.NewClient(conn)

+2 -0 shared/ssh.go #

......@@ -1,6 +1,7 @@
package shared

import (
	"fmt"
	"log/slog"

	"github.com/charmbracelet/ssh"

......@@ -26,6 +27,7 @@ func NewSshAuthHandler(dbh AuthFindUser, logger *slog.Logger) *SshAuthHandler {

func (r *SshAuthHandler) PubkeyAuthHandler(ctx ssh.Context, key ssh.PublicKey) bool {
	pubkey := utils.KeyForKeyText(key)
	fmt.Println("ACTUAL", pubkey)
	user, err := r.DB.FindUserByPubkey(pubkey)
	if err != nil {
		r.Logger.Error(

...	...		@@ -146,17 +284,27 @@ func GenerateUser() UserSSH {
146	284		panic(err)
147	285		}
148	286
	287	+	b, err := x509.MarshalPKCS8PrivateKey(userKey)
	288	+	if err != nil {
	289	+	panic(err)
	290	+	}
	291	+
149	292		userSigner, err := ssh.NewSignerFromKey(userKey)
150	293		if err != nil {
151	294		panic(err)
152	295		}
153	296
154	297		return UserSSH{
155		-	username: "testuser",
156		-	signer: userSigner,
	298	+	username: "testuser",
	299	+	signer: userSigner,
	300	+	privateKey: b,
157	301		}
158	302		}
159	303
	304	+	func WriteFilesWithRsync(cfg PgsConfig, conn ssh.Client, files []string) (*os.FileInfo, error) {
	305	+	return nil, nil
	306	+	}
	307	+
160	308		func WriteFileWithSftp(cfg PgsConfig, conn ssh.Client) (*os.FileInfo, error) {
161	309		// open an SFTP session over an existing ssh connection.
162	310		client, err := sftp.NewClient(conn)

...	...		@@ -3,9 +3,14 @@ package pgs
3	3		import (
4	4		"crypto/ed25519"
5	5		"crypto/rand"
	6	+	"crypto/x509"
	7	+	"encoding/pem"
	8	+	"fmt"
6	9		"io"
7	10		"log/slog"
8	11		"os"
	12	+	"os/exec"
	13	+	"path/filepath"
9	14		"strings"
10	15		"testing"
11	16		"time"

...	...		@@ -18,7 +23,7 @@ import (
18	23		"golang.org/x/crypto/ssh"
19	24		)
20	25
21		-	func TestSshServer(t *testing.T) {
	26	+	func TestSshServerSftp(t *testing.T) {
22	27		logger := slog.Default()
23	28		dbpool := pgsdb.NewDBMemory(logger)
24	29		// setup test data

...	...		@@ -57,9 +62,142 @@ func TestSshServer(t *testing.T) {
57	62		done <- nil
58	63		}
59	64
	65	+	func TestSshServerRsync(t *testing.T) {
	66	+	logger := slog.Default()
	67	+	dbpool := pgsdb.NewDBMemory(logger)
	68	+	// setup test data
	69	+	dbpool.SetupTestData()
	70	+	st, err := storage.NewStorageMemory(map[string]map[string]string{})
	71	+	if err != nil {
	72	+	panic(err)
	73	+	}
	74	+	cfg := NewPgsConfig(logger, dbpool, st)
	75	+	done := make(chan error)
	76	+	go StartSshServer(cfg, done)
	77	+	// Hack to wait for startup
	78	+	time.Sleep(time.Millisecond * 100)
	79	+
	80	+	user := GenerateUser()
	81	+	key := utils.KeyForKeyText(user.signer.PublicKey())
	82	+	// add user's pubkey to the default test account
	83	+	dbpool.Pubkeys = append(dbpool.Pubkeys, &db.PublicKey{
	84	+	ID: "nice-pubkey",
	85	+	UserID: dbpool.Users[0].ID,
	86	+	Key: key,
	87	+	})
	88	+
	89	+	conn, err := user.NewClient()
	90	+	if err != nil {
	91	+	t.Error(err)
	92	+	return
	93	+	}
	94	+	defer conn.Close()
	95	+
	96	+	// open an SFTP session over an existing ssh connection.
	97	+	client, err := sftp.NewClient(conn)
	98	+	if err != nil {
	99	+	cfg.Logger.Error("could not create sftp client", "err", err)
	100	+	panic(err)
	101	+	}
	102	+	defer client.Close()
	103	+
	104	+	name, err := os.MkdirTemp("", "rsync-")
	105	+	if err != nil {
	106	+	panic(err)
	107	+	}
	108	+
	109	+	// remove the temporary directory at the end of the program
	110	+	defer os.RemoveAll(name)
	111	+
	112	+	block := &pem.Block{
	113	+	Type: "PRIVATE KEY",
	114	+	Bytes: user.privateKey,
	115	+	}
	116	+	keyFile := filepath.Join(name, "id_ed25519")
	117	+	err = os.WriteFile(
	118	+	keyFile,
	119	+	pem.EncodeToMemory(block), 0600,
	120	+	)
	121	+
	122	+	index := "<!doctype html><html><body>index</body></html>"
	123	+	err = os.WriteFile(
	124	+	filepath.Join(name, "index.html"),
	125	+	[]byte(index), 0666,
	126	+	)
	127	+
	128	+	about := "<!doctype html><html><body>about</body></html>"
	129	+	aboutFile := filepath.Join(name, "about.html")
	130	+	err = os.WriteFile(
	131	+	aboutFile,
	132	+	[]byte(about), 0666,
	133	+	)
	134	+
	135	+	contact := "<!doctype html><html><body>contact</body></html>"
	136	+	err = os.WriteFile(
	137	+	filepath.Join(name, "contact.html"),
	138	+	[]byte(contact), 0666,
	139	+	)
	140	+
	141	+	eCmd := fmt.Sprintf(
	142	+	`"ssh -p 2222 -o IdentitiesOnly=yes -i %s -o StrictHostKeyChecking=no"`,
	143	+	keyFile,
	144	+	)
	145	+
	146	+	// copy files
	147	+	cmd := exec.Command("rsync", "-rv", "-e", eCmd, name+"/", "localhost:/test")
	148	+	fmt.Println(cmd.Args)
	149	+	result, err := cmd.CombinedOutput()
	150	+	if err != nil {
	151	+	fmt.Println(string(result), err)
	152	+	t.Error(err)
	153	+	return
	154	+	}
	155	+
	156	+	// check it's there
	157	+	fi, err := client.Lstat("about.html")
	158	+	if err != nil {
	159	+	cfg.Logger.Error("could not get stat for file", "err", err)
	160	+	t.Error("about.html not found")
	161	+	return
	162	+	}
	163	+	if fi.Size() != 0 {
	164	+	cfg.Logger.Error("about.html wrong size", "size", fi.Size())
	165	+	t.Error("about.html wrong size")
	166	+	return
	167	+	}
	168	+
	169	+	// remove about file
	170	+	os.Remove(aboutFile)
	171	+
	172	+	// copy files with delete
	173	+	delCmd := exec.Command("rsync", "-rv", "--delete", "-e", eCmd, name+"/", "localhost:/test")
	174	+	err = delCmd.Run()
	175	+	if err != nil {
	176	+	t.Error(err)
	177	+	return
	178	+	}
	179	+
	180	+	done <- nil
	181	+	}
	182	+
	183	+	func createTmpFile(name, contents, ext string) *os.File {
	184	+	file, err := os.CreateTemp("tmp", fmt.Sprintf("%s-*.%s", name, ext))
	185	+	if err != nil {
	186	+	panic(err)
	187	+	}
	188	+
	189	+	data := []byte(contents)
	190	+	if _, err := file.Write(data); err != nil {
	191	+	panic(err)
	192	+	}
	193	+
	194	+	return file
	195	+	}
	196	+
60	197		type UserSSH struct {
61		-	username string
62		-	signer ssh.Signer
	198	+	username string
	199	+	signer ssh.Signer
	200	+	privateKey []byte
63	201		}
64	202
65	203		func NewUserSSH(username string, signer ssh.Signer) *UserSSH {

...	...		@@ -1,6 +1,7 @@
1	1		package shared
2	2
3	3		import (
	4	+	"fmt"
4	5		"log/slog"
5	6
6	7		"github.com/charmbracelet/ssh"

...	...		@@ -26,6 +27,7 @@ func NewSshAuthHandler(dbh AuthFindUser, logger slog.Logger) SshAuthHandler {
26	27
27	28		func (r *SshAuthHandler) PubkeyAuthHandler(ctx ssh.Context, key ssh.PublicKey) bool {
28	29		pubkey := utils.KeyForKeyText(key)
	30	+	fmt.Println("ACTUAL", pubkey)
29	31		user, err := r.DB.FindUserByPubkey(pubkey)
30	32		if err != nil {
31	33		r.Logger.Error(

pico

Patchset 47.2 on 2025-02-21T21:21:15Z · commit 745b513

Patchset `47.2` on 2025-02-21T21:21:15Z · commit 745b513