chore: rm dead code - pico@5f240f0

Commit `5f240f0`

Eric Bower · 2026-04-20 21:26:04 -0400 EDT

parent c26a047

chore: rm dead code

1 files changed, +0, -274

D pkg/storage/handler.go

+0, -274

......@@ -1,274 +0,0 @@
package storage

import (
	"bytes"
	"encoding/binary"
	"fmt"
	"io"
	"log/slog"
	"os"
	"path/filepath"
	"time"

	"github.com/picosh/pico/pkg/pssh"
	"github.com/picosh/pico/pkg/send/utils"
)

type ctxBucketKey struct{}

func getBucket(ctx *pssh.SSHServerConnSession) (Bucket, error) {
	bucket, ok := ctx.Value(ctxBucketKey{}).(Bucket)
	if !ok {
		return bucket, fmt.Errorf("bucket not set on `ssh.Context()` for connection")
	}
	if bucket.Name == "" {
		return bucket, fmt.Errorf("bucket not set on `ssh.Context()` for connection")
	}
	return bucket, nil
}
func setBucket(ctx *pssh.SSHServerConnSession, bucket Bucket) {
	ctx.SetValue(ctxBucketKey{}, bucket)
}

type FileData struct {
	*utils.FileEntry
	Text   []byte
	User   string
	Bucket Bucket
}

type Config struct {
	Logger     *slog.Logger
	Storage    StorageServe
	AssetNames AssetNames
}

type UploadAssetHandler struct {
	Cfg *Config
}

var _ utils.CopyFromClientHandler = &UploadAssetHandler{}
var _ utils.CopyFromClientHandler = (*UploadAssetHandler)(nil)

func NewUploadAssetHandler(cfg *Config) *UploadAssetHandler {
	if cfg.AssetNames == nil {
		cfg.AssetNames = &AssetNamesBasic{}
	}

	return &UploadAssetHandler{
		Cfg: cfg,
	}
}

func (h *UploadAssetHandler) GetLogger(s *pssh.SSHServerConnSession) *slog.Logger {
	return h.Cfg.Logger
}

func (h *UploadAssetHandler) Delete(s *pssh.SSHServerConnSession, entry *utils.FileEntry) error {
	h.Cfg.Logger.Info("deleting file", "file", entry.Filepath)
	bucket, err := getBucket(s)
	if err != nil {
		h.Cfg.Logger.Error(err.Error())
		return err
	}

	objectFileName, err := h.Cfg.AssetNames.ObjectName(s, entry)
	if err != nil {
		return err
	}
	return h.Cfg.Storage.DeleteObject(bucket, objectFileName)
}

func (h *UploadAssetHandler) Read(s *pssh.SSHServerConnSession, entry *utils.FileEntry) (os.FileInfo, utils.ReadAndReaderAtCloser, error) {
	fileInfo := &utils.VirtualFile{
		FName:    filepath.Base(entry.Filepath),
		FIsDir:   false,
		FSize:    entry.Size,
		FModTime: time.Unix(entry.Mtime, 0),
	}
	h.Cfg.Logger.Info("reading file", "file", fileInfo)

	bucketName, err := h.Cfg.AssetNames.BucketName(s)
	if err != nil {
		return nil, nil, err
	}
	bucket, err := h.Cfg.Storage.GetBucket(bucketName)
	if err != nil {
		return nil, nil, err
	}

	fname, err := h.Cfg.AssetNames.ObjectName(s, entry)
	if err != nil {
		return nil, nil, err
	}
	contents, info, err := h.Cfg.Storage.GetObject(bucket, fname)
	if err != nil {
		return nil, nil, err
	}

	fileInfo.FSize = info.Size
	fileInfo.FModTime = info.LastModified

	return fileInfo, contents, nil
}

func (h *UploadAssetHandler) List(s *pssh.SSHServerConnSession, fpath string, isDir bool, recursive bool) ([]os.FileInfo, error) {
	h.Cfg.Logger.Info(
		"listing path",
		"dir", fpath,
		"isDir", isDir,
		"recursive", recursive,
	)
	var fileList []os.FileInfo

	cleanFilename := fpath

	bucketName, err := h.Cfg.AssetNames.BucketName(s)
	if err != nil {
		return fileList, err
	}
	bucket, err := h.Cfg.Storage.GetBucket(bucketName)
	if err != nil {
		return fileList, err
	}

	fname, err := h.Cfg.AssetNames.ObjectName(s, &utils.FileEntry{Filepath: cleanFilename})
	if err != nil {
		return fileList, err
	}

	if fname == "" || fname == "." {
		name := fname
		if name == "" {
			name = "/"
		}

		info := &utils.VirtualFile{
			FName:  name,
			FIsDir: true,
		}

		fileList = append(fileList, info)
	} else {
		name := fname
		if name != "/" && isDir {
			name += "/"
		}

		foundList, err := h.Cfg.Storage.ListObjects(bucket, name, recursive)
		if err != nil {
			return fileList, err
		}

		fileList = append(fileList, foundList...)
	}

	return fileList, nil
}

func (h *UploadAssetHandler) Validate(s *pssh.SSHServerConnSession) error {
	var err error
	userName := s.User()

	assetBucket, err := h.Cfg.AssetNames.BucketName(s)
	if err != nil {
		return err
	}
	bucket, err := h.Cfg.Storage.UpsertBucket(assetBucket)
	if err != nil {
		return err
	}
	setBucket(s, bucket)

	pk, _ := utils.KeyText(s)
	h.Cfg.Logger.Info(
		"attempting to upload files",
		"user", userName,
		"bucket", bucket.Name,
		"publicKey", pk,
	)
	return nil
}

func (h *UploadAssetHandler) Write(s *pssh.SSHServerConnSession, entry *utils.FileEntry) (string, error) {
	var origText []byte
	if b, err := io.ReadAll(entry.Reader); err == nil {
		origText = b
	}
	fileSize := binary.Size(origText)
	// TODO: hack for now until I figure out how to get correct
	// filesize from sftp,scp,rsync
	entry.Size = int64(fileSize)
	userName := s.User()

	bucket, err := getBucket(s)
	if err != nil {
		h.Cfg.Logger.Error(err.Error())
		return "", err
	}

	data := &FileData{
		FileEntry: entry,
		User:      userName,
		Text:      origText,
		Bucket:    bucket,
	}
	err = h.writeAsset(s, data)
	if err != nil {
		h.Cfg.Logger.Error(err.Error())
		return "", err
	}

	url, err := h.Cfg.AssetNames.PrintObjectName(s, entry, bucket.Name)
	if err != nil {
		return "", err
	}
	return url, nil
}

func (h *UploadAssetHandler) validateAsset(_ *FileData) (bool, error) {
	return true, nil
}

func (h *UploadAssetHandler) writeAsset(s *pssh.SSHServerConnSession, data *FileData) error {
	valid, err := h.validateAsset(data)
	if !valid {
		return err
	}

	objectFileName, err := h.Cfg.AssetNames.ObjectName(s, data.FileEntry)
	if err != nil {
		return err
	}
	reader := bytes.NewReader(data.Text)

	h.Cfg.Logger.Info(
		"uploading file to bucket",
		"user",
		data.User,
		"bucket",
		data.Bucket.Name,
		"object",
		objectFileName,
	)

	var mtime time.Time
	if data.Mtime > 0 {
		mtime = time.Unix(data.Mtime, 0)
	}
	info := &ObjectInfo{
		LastModified: mtime,
	}

	_, _, err = h.Cfg.Storage.PutObject(
		data.Bucket,
		objectFileName,
		utils.NopReadAndReaderAtCloser(reader),
		info,
	)
	if err != nil {
		return err
	}

	return nil
}

...	...		@@ -1,274 +0,0 @@
1		-	package storage
2		-
3		-	import (
4		-	"bytes"
5		-	"encoding/binary"
6		-	"fmt"
7		-	"io"
8		-	"log/slog"
9		-	"os"
10		-	"path/filepath"
11		-	"time"
12		-
13		-	"github.com/picosh/pico/pkg/pssh"
14		-	"github.com/picosh/pico/pkg/send/utils"
15		-	)
16		-
17		-	type ctxBucketKey struct{}
18		-
19		-	func getBucket(ctx *pssh.SSHServerConnSession) (Bucket, error) {
20		-	bucket, ok := ctx.Value(ctxBucketKey{}).(Bucket)
21		-	if !ok {
22		-	return bucket, fmt.Errorf("bucket not set on `ssh.Context()` for connection")
23		-	}
24		-	if bucket.Name == "" {
25		-	return bucket, fmt.Errorf("bucket not set on `ssh.Context()` for connection")
26		-	}
27		-	return bucket, nil
28		-	}
29		-	func setBucket(ctx *pssh.SSHServerConnSession, bucket Bucket) {
30		-	ctx.SetValue(ctxBucketKey{}, bucket)
31		-	}
32		-
33		-	type FileData struct {
34		-	*utils.FileEntry
35		-	Text []byte
36		-	User string
37		-	Bucket Bucket
38		-	}
39		-
40		-	type Config struct {
41		-	Logger *slog.Logger
42		-	Storage StorageServe
43		-	AssetNames AssetNames
44		-	}
45		-
46		-	type UploadAssetHandler struct {
47		-	Cfg *Config
48		-	}
49		-
50		-	var _ utils.CopyFromClientHandler = &UploadAssetHandler{}
51		-	var _ utils.CopyFromClientHandler = (*UploadAssetHandler)(nil)
52		-
53		-	func NewUploadAssetHandler(cfg Config) UploadAssetHandler {
54		-	if cfg.AssetNames == nil {
55		-	cfg.AssetNames = &AssetNamesBasic{}
56		-	}
57		-
58		-	return &UploadAssetHandler{
59		-	Cfg: cfg,
60		-	}
61		-	}
62		-
63		-	func (h UploadAssetHandler) GetLogger(s pssh.SSHServerConnSession) *slog.Logger {
64		-	return h.Cfg.Logger
65		-	}
66		-
67		-	func (h UploadAssetHandler) Delete(s pssh.SSHServerConnSession, entry *utils.FileEntry) error {
68		-	h.Cfg.Logger.Info("deleting file", "file", entry.Filepath)
69		-	bucket, err := getBucket(s)
70		-	if err != nil {
71		-	h.Cfg.Logger.Error(err.Error())
72		-	return err
73		-	}
74		-
75		-	objectFileName, err := h.Cfg.AssetNames.ObjectName(s, entry)
76		-	if err != nil {
77		-	return err
78		-	}
79		-	return h.Cfg.Storage.DeleteObject(bucket, objectFileName)
80		-	}
81		-
82		-	func (h UploadAssetHandler) Read(s pssh.SSHServerConnSession, entry *utils.FileEntry) (os.FileInfo, utils.ReadAndReaderAtCloser, error) {
83		-	fileInfo := &utils.VirtualFile{
84		-	FName: filepath.Base(entry.Filepath),
85		-	FIsDir: false,
86		-	FSize: entry.Size,
87		-	FModTime: time.Unix(entry.Mtime, 0),
88		-	}
89		-	h.Cfg.Logger.Info("reading file", "file", fileInfo)
90		-
91		-	bucketName, err := h.Cfg.AssetNames.BucketName(s)
92		-	if err != nil {
93		-	return nil, nil, err
94		-	}
95		-	bucket, err := h.Cfg.Storage.GetBucket(bucketName)
96		-	if err != nil {
97		-	return nil, nil, err
98		-	}
99		-
100		-	fname, err := h.Cfg.AssetNames.ObjectName(s, entry)
101		-	if err != nil {
102		-	return nil, nil, err
103		-	}
104		-	contents, info, err := h.Cfg.Storage.GetObject(bucket, fname)
105		-	if err != nil {
106		-	return nil, nil, err
107		-	}
108		-
109		-	fileInfo.FSize = info.Size
110		-	fileInfo.FModTime = info.LastModified
111		-
112		-	return fileInfo, contents, nil
113		-	}
114		-
115		-	func (h UploadAssetHandler) List(s pssh.SSHServerConnSession, fpath string, isDir bool, recursive bool) ([]os.FileInfo, error) {
116		-	h.Cfg.Logger.Info(
117		-	"listing path",
118		-	"dir", fpath,
119		-	"isDir", isDir,
120		-	"recursive", recursive,
121		-	)
122		-	var fileList []os.FileInfo
123		-
124		-	cleanFilename := fpath
125		-
126		-	bucketName, err := h.Cfg.AssetNames.BucketName(s)
127		-	if err != nil {
128		-	return fileList, err
129		-	}
130		-	bucket, err := h.Cfg.Storage.GetBucket(bucketName)
131		-	if err != nil {
132		-	return fileList, err
133		-	}
134		-
135		-	fname, err := h.Cfg.AssetNames.ObjectName(s, &utils.FileEntry{Filepath: cleanFilename})
136		-	if err != nil {
137		-	return fileList, err
138		-	}
139		-
140		-	if fname == "" \|\| fname == "." {
141		-	name := fname
142		-	if name == "" {
143		-	name = "/"
144		-	}
145		-
146		-	info := &utils.VirtualFile{
147		-	FName: name,
148		-	FIsDir: true,
149		-	}
150		-
151		-	fileList = append(fileList, info)
152		-	} else {
153		-	name := fname
154		-	if name != "/" && isDir {
155		-	name += "/"
156		-	}
157		-
158		-	foundList, err := h.Cfg.Storage.ListObjects(bucket, name, recursive)
159		-	if err != nil {
160		-	return fileList, err
161		-	}
162		-
163		-	fileList = append(fileList, foundList...)
164		-	}
165		-
166		-	return fileList, nil
167		-	}
168		-
169		-	func (h UploadAssetHandler) Validate(s pssh.SSHServerConnSession) error {
170		-	var err error
171		-	userName := s.User()
172		-
173		-	assetBucket, err := h.Cfg.AssetNames.BucketName(s)
174		-	if err != nil {
175		-	return err
176		-	}
177		-	bucket, err := h.Cfg.Storage.UpsertBucket(assetBucket)
178		-	if err != nil {
179		-	return err
180		-	}
181		-	setBucket(s, bucket)
182		-
183		-	pk, _ := utils.KeyText(s)
184		-	h.Cfg.Logger.Info(
185		-	"attempting to upload files",
186		-	"user", userName,
187		-	"bucket", bucket.Name,
188		-	"publicKey", pk,
189		-	)
190		-	return nil
191		-	}
192		-
193		-	func (h UploadAssetHandler) Write(s pssh.SSHServerConnSession, entry *utils.FileEntry) (string, error) {
194		-	var origText []byte
195		-	if b, err := io.ReadAll(entry.Reader); err == nil {
196		-	origText = b
197		-	}
198		-	fileSize := binary.Size(origText)
199		-	// TODO: hack for now until I figure out how to get correct
200		-	// filesize from sftp,scp,rsync
201		-	entry.Size = int64(fileSize)
202		-	userName := s.User()
203		-
204		-	bucket, err := getBucket(s)
205		-	if err != nil {
206		-	h.Cfg.Logger.Error(err.Error())
207		-	return "", err
208		-	}
209		-
210		-	data := &FileData{
211		-	FileEntry: entry,
212		-	User: userName,
213		-	Text: origText,
214		-	Bucket: bucket,
215		-	}
216		-	err = h.writeAsset(s, data)
217		-	if err != nil {
218		-	h.Cfg.Logger.Error(err.Error())
219		-	return "", err
220		-	}
221		-
222		-	url, err := h.Cfg.AssetNames.PrintObjectName(s, entry, bucket.Name)
223		-	if err != nil {
224		-	return "", err
225		-	}
226		-	return url, nil
227		-	}
228		-
229		-	func (h UploadAssetHandler) validateAsset(_ FileData) (bool, error) {
230		-	return true, nil
231		-	}
232		-
233		-	func (h UploadAssetHandler) writeAsset(s pssh.SSHServerConnSession, data *FileData) error {
234		-	valid, err := h.validateAsset(data)
235		-	if !valid {
236		-	return err
237		-	}
238		-
239		-	objectFileName, err := h.Cfg.AssetNames.ObjectName(s, data.FileEntry)
240		-	if err != nil {
241		-	return err
242		-	}
243		-	reader := bytes.NewReader(data.Text)
244		-
245		-	h.Cfg.Logger.Info(
246		-	"uploading file to bucket",
247		-	"user",
248		-	data.User,
249		-	"bucket",
250		-	data.Bucket.Name,
251		-	"object",
252		-	objectFileName,
253		-	)
254		-
255		-	var mtime time.Time
256		-	if data.Mtime > 0 {
257		-	mtime = time.Unix(data.Mtime, 0)
258		-	}
259		-	info := &ObjectInfo{
260		-	LastModified: mtime,
261		-	}
262		-
263		-	_, _, err = h.Cfg.Storage.PutObject(
264		-	data.Bucket,
265		-	objectFileName,
266		-	utils.NopReadAndReaderAtCloser(reader),
267		-	info,
268		-	)
269		-	if err != nil {
270		-	return err
271		-	}
272		-
273		-	return nil
274		-	}

Commit 5f240f0

Commit `5f240f0`