Merge pull request #24 from rtmelsov/develop

Develop

Author: rtmelsov

api/proto/file/v1/file.proto

@@ -1,4 +1,3 @@
-
 syntax = "proto3";
 
 package file.v1;
@@ -55,11 +54,15 @@ message UploadResponse {
   string sha256         = 3; // контрольная сумма принятого
 }
 
+message FileEof {
+  string sha256_hex = 1;
+}
 
 message DownloadFileResponse {
   oneof payload {
     FileInfo info = 1;   // ПЕРВОЕ сообщение — мета-инфа
     FileChunk chunk = 2; // Далее — куски файла
+    FileEof eof = 3;
   }
 }
 

db/queries/auth.sql

@@ -33,3 +33,4 @@ WHERE id = $1;
 SELECT id, user_id, filename, path, size_bytes, created_at
 FROM files
 WHERE id = $1 AND user_id = $2;
+

docs/screenshot.png

@@ -2,11 +2,12 @@ package akclient
 
 import (
 	"crypto/sha256"
+	"encoding/hex"
 	"fmt"
 	"io"
-	"log"
 	"os"
 	"path/filepath"
+	"strings"
 
 	"google.golang.org/grpc"
 
@@ -22,53 +23,35 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-func safeBase(name string) string {
-	// убираем директории и опасные символы
-	base := filepath.Base(name)
-	runes := make([]rune, 0, len(base))
-	for _, r := range base {
-		switch {
-		case r >= 'a' && r <= 'z',
-			r >= 'A' && r <= 'Z',
-			r >= '0' && r <= '9',
-			r == '.', r == '-', r == '_', r == ' ':
-			runes = append(runes, r)
-		}
-	}
-	if len(runes) == 0 {
-		return "file"
-	}
-	// защитим длину
-	if len(runes) > 128 {
-		runes = runes[:128]
-	}
-	return string(runes)
-}
 func DownloadFile(fileID string, prog chan<- models.Prog) {
 	defer close(prog)
+
 	ctx, err := middleware.AddAuthData()
 	if err != nil {
 		prog <- models.Prog{Err: err}
 		return
 	}
-	outDir := helpers.DownloadFilesDir
-	conn, err := grpc.NewClient(helpers.Addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
+
+	outDir, err := helpers.GetDownloadsDir()
 	if err != nil {
 		prog <- models.Prog{Err: err}
-		log.Fatalf("dial %s: %v", helpers.Addr, err)
+		return
+	}
+
+	conn, err := grpc.DialContext(ctx, helpers.Addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	if err != nil {
+		prog <- models.Prog{Err: err}
+		return
 	}
 	defer conn.Close()
 
-	// 2) gRPC-клиент
 	c := filev1.NewFileServiceClient(conn)
-
 	stream, err := c.DownloadFile(ctx, &filev1.DownloadFileRequest{Fileid: fileID})
 	if err != nil {
 		prog <- models.Prog{Err: err}
 		return
 	}
 
-	// 1) ждём FileInfo
 	first, err := stream.Recv()
 	if err != nil {
 		prog <- models.Prog{Err: status.Errorf(codes.Internal, "read: %v", err)}
@@ -80,12 +63,9 @@ func DownloadFile(fileID string, prog chan<- models.Prog) {
 		return
 	}
 
-	filename := safeBase(info.GetFilename())
-	if filename == "" {
-		filename = "file"
-	}
+	filename := helpers.NextAvailableName(outDir, info.GetFilename())
+	total := info.GetSize()
 
-	// 2) готовим пути/директории
 	if err := os.MkdirAll(outDir, 0o755); err != nil {
 		prog <- models.Prog{Err: fmt.Errorf("mkdir: %w", err)}
 		return
@@ -98,78 +78,95 @@ func DownloadFile(fileID string, prog chan<- models.Prog) {
 		prog <- models.Prog{Err: fmt.Errorf("create: %w", err)}
 		return
 	}
+	var retErr error
 	defer func() {
-		out.Close()
-		if err != nil {
-			_ = os.Remove(tmpPath)
+		_ = out.Close()
+		if retErr != nil {
+			_ = os.Remove(tmpPath) // удаляем именно .part при ошибке
 		}
 	}()
 
-	stat, err := out.Stat()
-	if err != nil {
-		prog <- models.Prog{Err: err}
-		return
-	}
-	total := stat.Size()
-
 	h := sha256.New()
 	var written int64
+	var eofHex string
 
 	for {
 		if ctx.Err() != nil {
-			prog <- models.Prog{Err: ctx.Err()}
+			retErr = ctx.Err()
+			prog <- models.Prog{Err: retErr}
 			return
 		}
+
 		msg, rerr := stream.Recv()
 		if rerr == io.EOF {
 			break
 		}
 		if rerr != nil {
-			// красиво покажем gRPC статус
 			if st, ok := status.FromError(rerr); ok {
-				prog <- models.Prog{Err: fmt.Errorf("recv: %s", st.Message())}
-				return
+				retErr = fmt.Errorf("recv: %s", st.Message())
+			} else {
+				retErr = fmt.Errorf("recv: %w", rerr)
 			}
-			prog <- models.Prog{Err: fmt.Errorf("recv: %w", rerr)}
-			return
-		}
-
-		ch := msg.GetChunk()
-		if ch == nil {
-			prog <- models.Prog{Err: errors.New("unexpected message: want FileChunk")}
+			prog <- models.Prog{Err: retErr}
 			return
 		}
 
-		n, werr := out.Write(ch.Content)
-		if werr != nil {
-			prog <- models.Prog{Err: fmt.Errorf("write: %w", werr)}
-			return
+		if e := msg.GetEof(); e != nil {
+			eofHex = strings.ToLower(strings.TrimSpace(e.GetSha256Hex()))
+			continue
 		}
-		written += int64(n)
-		select {
-		case prog <- models.Prog{Done: written, Total: total}:
-		default: // не блокируем UI, если буфер заполнен
+		if ch := msg.GetChunk(); ch != nil {
+			n, werr := out.Write(ch.Content)
+			if werr != nil {
+				retErr = fmt.Errorf("write: %w", werr)
+				prog <- models.Prog{Err: retErr}
+				return
+			}
+			written += int64(n)
+			select {
+			case prog <- models.Prog{Done: written, Total: total}:
+			default:
+			}
+			_, _ = h.Write(ch.Content)
+			continue
 		}
-		_, _ = h.Write(ch.Content)
+
+		retErr = errors.New("unexpected message: want chunk or eof")
+		prog <- models.Prog{Err: retErr}
+		return
 	}
 
-	// 4) fsync → close → rename
-	if err := out.Sync(); err != nil {
-		prog <- models.Prog{Err: fmt.Errorf("sync: %w", err)}
+	gotHex := strings.ToLower(hex.EncodeToString(h.Sum(nil)))
+
+	if eofHex == "" {
+		retErr = errors.New("missing EOF sha256 from server")
+		prog <- models.Prog{Err: retErr}
 		return
 	}
-	if err := out.Close(); err != nil {
-		prog <- models.Prog{Err: fmt.Errorf("close: %w", err)}
+	if !strings.EqualFold(gotHex, eofHex) {
+		retErr = fmt.Errorf("sha256 mismatch: got %s, want %s", gotHex, eofHex)
+		prog <- models.Prog{Err: retErr}
 		return
 	}
-	if err := os.Rename(tmpPath, finalPath); err != nil {
-		prog <- models.Prog{Err: fmt.Errorf("rename: %w", err)}
+	if total > 0 && written != total {
+		retErr = fmt.Errorf("size mismatch: got %d, want %d", written, total)
+		prog <- models.Prog{Err: retErr}
 		return
 	}
 
-	// 5) сверим размер (если сервер прислал size)
-	if info.Size > 0 && written != info.Size {
-		prog <- models.Prog{Err: fmt.Errorf("size mismatch: got %d, want %d", written, info.Size)}
+	if err := out.Sync(); err != nil {
+		retErr = fmt.Errorf("sync: %w", err)
+		prog <- models.Prog{Err: retErr}
+		return
+	}
+	if err := out.Close(); err != nil {
+		retErr = fmt.Errorf("close: %w", err)
+		prog <- models.Prog{Err: retErr}
+		return
+	}
+	if err := os.Rename(tmpPath, finalPath); err != nil {
+		retErr = fmt.Errorf("rename: %w", err)
+		prog <- models.Prog{Err: retErr}
 		return
 	}
 }

gen/go/proto/file/v1/file.pb.go

@@ -5,7 +5,6 @@ import (
 	"encoding/hex"
 	"io"
 	"os"
-	"path/filepath"
 
 	"github.com/google/uuid"
 
@@ -58,7 +57,7 @@ func (s *Service) DownloadFile(DownloadFileRequest *filev1.DownloadFileRequest,
 	err = stream.Send(&filev1.DownloadFileResponse{
 		Payload: &filev1.DownloadFileResponse_Info{
 			Info: &filev1.FileInfo{
-				Filename: filepath.Base(path),
+				Filename: u.Filename,
 				Size:     stat.Size(),
 			},
 		},
@@ -93,19 +92,26 @@ func (s *Service) DownloadFile(DownloadFileRequest *filev1.DownloadFileRequest,
 			}
 		}
 		if rerr == io.EOF {
-			break
+			if err := stream.Send(&filev1.DownloadFileResponse{
+				Payload: &filev1.DownloadFileResponse_Eof{
+					Eof: &filev1.FileEof{Sha256Hex: hex.EncodeToString(h.Sum(nil))},
+				},
+			}); err != nil {
+				return err
+			}
+
+			// 3) закрываем отправку и получаем ответ
+			log.Info("download done",
+				"file", u.Path,
+				"bytes", u.SizeBytes,
+				"sha256", hex.EncodeToString(h.Sum(nil)),
+			)
+			return nil
 		}
 		if rerr != nil {
 			return status.Errorf(codes.Internal, "read: %v", rerr)
 		}
 	}
 
-	// 3) закрываем отправку и получаем ответ
-	log.Info("download done",
-		"file", u.Path,
-		"bytes", u.SizeBytes,
-		"sha256", hex.EncodeToString(h.Sum(nil)),
-	)
 	return nil
-
 }