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.1` on 2025-02-21T21:07:49Z · commit 971b354

chore: rsync test

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

→ test

Eric Bower 2025-02-21T21:07:22Z

test

Eric Bower 2025-02-21T21:07:22Z

Semantic diff summary

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

pgs/ssh_test.go

chunk lines 3-16 modified
function_declaration createTmpFile added
type_declaration UserSSH modified
function_declaration GenerateUser modified

shared/ssh.go

chunk lines 1-7 modified
function_declaration NewSshAuthHandler modified

+108 -10 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"

......@@ -73,39 +78,126 @@ func TestSshServerRsync(t *testing.T) {
	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:    utils.KeyForKeyText(user.signer.PublicKey()),
		Key:    key,
	})

	/* client, err := user.NewClient()
	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()

	_, err = WriteFilesWithRsync(cfg, client, []string{"index.html", "about.html", "favicon.png", "profile.jpg"})
	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
	}

	// test `--delete` functionality
	_, err = WriteFilesWithRsync(cfg, client, []string{"index.html", "profile.jpg"})
	// 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 {

......@@ -192,14 +284,20 @@ 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,
	}
}

+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(

...	...		@@ -73,39 +78,126 @@ func TestSshServerRsync(t *testing.T) {
73	78		time.Sleep(time.Millisecond * 100)
74	79
75	80		user := GenerateUser()
	81	+	key := utils.KeyForKeyText(user.signer.PublicKey())
76	82		// add user's pubkey to the default test account
77	83		dbpool.Pubkeys = append(dbpool.Pubkeys, &db.PublicKey{
78	84		ID: "nice-pubkey",
79	85		UserID: dbpool.Users[0].ID,
80		-	Key: utils.KeyForKeyText(user.signer.PublicKey()),
	86	+	Key: key,
81	87		})
82	88
83		-	/* client, err := user.NewClient()
	89	+	conn, err := user.NewClient()
84	90		if err != nil {
85	91		t.Error(err)
86	92		return
87	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	+	}
88	102		defer client.Close()
89	103
90		-	_, err = WriteFilesWithRsync(cfg, client, []string{"index.html", "about.html", "favicon.png", "profile.jpg"})
	104	+	name, err := os.MkdirTemp("", "rsync-")
91	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)
92	152		t.Error(err)
93	153		return
94	154		}
95	155
96		-	// test `--delete` functionality
97		-	_, err = WriteFilesWithRsync(cfg, client, []string{"index.html", "profile.jpg"})
	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()
98	175		if err != nil {
99	176		t.Error(err)
100	177		return
101		-	} */
	178	+	}
102	179
103	180		done <- nil
104	181		}
105	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	+
106	197		type UserSSH struct {
107		-	username string
108		-	signer ssh.Signer
	198	+	username string
	199	+	signer ssh.Signer
	200	+	privateKey []byte
109	201		}
110	202
111	203		func NewUserSSH(username string, signer ssh.Signer) *UserSSH {

...	...		@@ -192,14 +284,20 @@ func GenerateUser() UserSSH {
192	284		panic(err)
193	285		}
194	286
	287	+	b, err := x509.MarshalPKCS8PrivateKey(userKey)
	288	+	if err != nil {
	289	+	panic(err)
	290	+	}
	291	+
195	292		userSigner, err := ssh.NewSignerFromKey(userKey)
196	293		if err != nil {
197	294		panic(err)
198	295		}
199	296
200	297		return UserSSH{
201		-	username: "testuser",
202		-	signer: userSigner,
	298	+	username: "testuser",
	299	+	signer: userSigner,
	300	+	privateKey: b,
203	301		}
204	302		}
205	303

...	...		@@ -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"

...	...		@@ -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.1 on 2025-02-21T21:07:49Z · commit 971b354

Patchset `47.1` on 2025-02-21T21:07:49Z · commit 971b354