Refactor snapshot methods to use active directory context

Updated `SaveSnapshot` and `RestoreSnapshot` methods to reference the active directory via `BlobStore`. Introduced `RestoreSnapshotToDir` for granular restore operations. Additionally, updated dependencies in `go.mod` to their latest versions for compatibility and maintenance.

Makefile

@@ -6,7 +6,7 @@ download-third-party:
 	mv ./grpc/third_party/googleapis/grafeas ./grpc
 	rm -rf ./grpc/third_party
 
-gen-proto-geolocation:
+gen-proto:
 	mkdir -p ./grpc
 
 	@protoc -I ./grpc \

README.md

@@ -0,0 +1,310 @@
+# Agate
+
+Agate is a Go library for creating, managing, and sharing snapshots of directories. It provides functionality for creating incremental snapshots, storing them efficiently, and sharing them over a network using gRPC.
+
+## Installation
+
+```bash
+go get gitea.unprism.ru/KRBL/Agate
+```
+
+## Features
+
+- Create snapshots of directories
+- Incremental snapshots (only store changes)
+- Restore snapshots
+- List and manage snapshots
+- Share snapshots over a network using gRPC
+- Connect to remote snapshot repositories
+
+## Basic Usage
+
+### Creating a Snapshot Repository
+
+To create a snapshot repository, you need to initialize the Agate library with the appropriate options:
+
+```go
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+
+	"gitea.unprism.ru/KRBL/Agate"
+	"gitea.unprism.ru/KRBL/Agate/stores"
+)
+
+func main() {
+	// Create directories for your repository
+	workDir := "/path/to/your/repository"
+	if err := os.MkdirAll(workDir, 0755); err != nil {
+		log.Fatalf("Failed to create work directory: %v", err)
+	}
+
+	// Initialize the default stores
+	metadataStore, blobStore, err := stores.InitDefaultStores(workDir)
+	if err != nil {
+		log.Fatalf("Failed to initialize stores: %v", err)
+	}
+	defer metadataStore.Close()
+
+	// Initialize Agate
+	agateOptions := agate.AgateOptions{
+		WorkDir:       workDir,
+		MetadataStore: metadataStore,
+		BlobStore:     blobStore,
+	}
+
+	ag, err := agate.New(agateOptions)
+	if err != nil {
+		log.Fatalf("Failed to initialize Agate: %v", err)
+	}
+	defer ag.Close()
+
+	// Create a snapshot
+	ctx := context.Background()
+	snapshotID, err := ag.SaveSnapshot(ctx, "My First Snapshot", "")
+	if err != nil {
+		log.Fatalf("Failed to create snapshot: %v", err)
+	}
+	fmt.Printf("Created snapshot with ID: %s\n", snapshotID)
+
+	// List snapshots
+	snapshots, err := ag.ListSnapshots(ctx)
+	if err != nil {
+		log.Fatalf("Failed to list snapshots: %v", err)
+	}
+	fmt.Printf("Found %d snapshots:\n", len(snapshots))
+	for _, s := range snapshots {
+		fmt.Printf("  - %s: %s (created at %s)\n", s.ID, s.Name, s.CreationTime.Format("2006-01-02 15:04:05"))
+	}
+}
+```
+
+### Hosting a Snapshot Repository
+
+To host a snapshot repository and make it available over the network, you can use the `StartServer` method:
+
+```go
+package main
+
+import (
+	"context"
+	"log"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"gitea.unprism.ru/KRBL/Agate"
+	"gitea.unprism.ru/KRBL/Agate/stores"
+)
+
+func main() {
+	// Create directories for your repository
+	workDir := "/path/to/your/repository"
+	if err := os.MkdirAll(workDir, 0755); err != nil {
+		log.Fatalf("Failed to create work directory: %v", err)
+	}
+
+	// Initialize the default stores
+	metadataStore, blobStore, err := stores.InitDefaultStores(workDir)
+	if err != nil {
+		log.Fatalf("Failed to initialize stores: %v", err)
+	}
+	defer metadataStore.Close()
+
+	// Initialize Agate
+	agateOptions := agate.AgateOptions{
+		WorkDir:       workDir,
+		MetadataStore: metadataStore,
+		BlobStore:     blobStore,
+	}
+
+	ag, err := agate.New(agateOptions)
+	if err != nil {
+		log.Fatalf("Failed to initialize Agate: %v", err)
+	}
+	defer ag.Close()
+
+	// Start the gRPC server
+	ctx := context.Background()
+	address := "0.0.0.0:50051" // Listen on all interfaces, port 50051
+	if err := ag.StartServer(ctx, address); err != nil {
+		log.Fatalf("Failed to start server: %v", err)
+	}
+
+	log.Printf("Server started on %s", address)
+
+	// Wait for termination signal
+	sigCh := make(chan os.Signal, 1)
+	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
+	<-sigCh
+
+	log.Println("Shutting down...")
+}
+```
+
+### Connecting to a Hosted Snapshot Repository
+
+To connect to a hosted snapshot repository and retrieve snapshots:
+
+```go
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+
+	"gitea.unprism.ru/KRBL/Agate"
+	"gitea.unprism.ru/KRBL/Agate/stores"
+)
+
+func main() {
+	// Create directories for your local repository
+	workDir := "/path/to/your/local/repository"
+	if err := os.MkdirAll(workDir, 0755); err != nil {
+		log.Fatalf("Failed to create work directory: %v", err)
+	}
+
+	// Initialize the default stores
+	metadataStore, blobStore, err := stores.InitDefaultStores(workDir)
+	if err != nil {
+		log.Fatalf("Failed to initialize stores: %v", err)
+	}
+	defer metadataStore.Close()
+
+	// Initialize Agate
+	agateOptions := agate.AgateOptions{
+		WorkDir:       workDir,
+		MetadataStore: metadataStore,
+		BlobStore:     blobStore,
+	}
+
+	ag, err := agate.New(agateOptions)
+	if err != nil {
+		log.Fatalf("Failed to initialize Agate: %v", err)
+	}
+	defer ag.Close()
+
+	// Connect to a remote server
+	ctx := context.Background()
+	remoteAddress := "remote-server:50051"
+
+	// List snapshots from the remote server
+	snapshots, err := ag.GetRemoteSnapshotList(ctx, remoteAddress)
+	if err != nil {
+		log.Fatalf("Failed to list remote snapshots: %v", err)
+	}
+
+	fmt.Printf("Found %d remote snapshots:\n", len(snapshots))
+	for _, s := range snapshots {
+		fmt.Printf("  - %s: %s (created at %s)\n", s.ID, s.Name, s.CreationTime.Format("2006-01-02 15:04:05"))
+	}
+
+	// Download a specific snapshot
+	if len(snapshots) > 0 {
+		snapshotID := snapshots[0].ID
+		fmt.Printf("Downloading snapshot %s...\n", snapshotID)
+
+		// Download the snapshot (pass empty string as localParentID if this is the first download)
+		if err := ag.GetRemoteSnapshot(ctx, remoteAddress, snapshotID, ""); err != nil {
+			log.Fatalf("Failed to download snapshot: %v", err)
+		}
+
+		fmt.Printf("Successfully downloaded snapshot %s\n", snapshotID)
+	}
+}
+```
+
+## Advanced Usage
+
+### Creating Incremental Snapshots
+
+You can create incremental snapshots by specifying a parent snapshot ID:
+
+```go
+// Create a first snapshot
+snapshotID1, err := ag.SaveSnapshot(ctx, "First Snapshot", "")
+if err != nil {
+    log.Fatalf("Failed to create first snapshot: %v", err)
+}
+
+// Make some changes to your files...
+
+// Create a second snapshot with the first one as parent
+snapshotID2, err := ag.SaveSnapshot(ctx, "Second Snapshot", snapshotID1)
+if err != nil {
+    log.Fatalf("Failed to create second snapshot: %v", err)
+}
+```
+
+### Restoring a Snapshot
+
+To restore a snapshot:
+
+```go
+if err := ag.RestoreSnapshot(ctx, snapshotID); err != nil {
+    log.Fatalf("Failed to restore snapshot: %v", err)
+}
+```
+
+### Getting Snapshot Details
+
+To get detailed information about a snapshot:
+
+```go
+snapshot, err := ag.GetSnapshotDetails(ctx, snapshotID)
+if err != nil {
+    log.Fatalf("Failed to get snapshot details: %v", err)
+}
+
+fmt.Printf("Snapshot: %s\n", snapshot.Name)
+fmt.Printf("Created: %s\n", snapshot.CreationTime.Format("2006-01-02 15:04:05"))
+fmt.Printf("Files: %d\n", len(snapshot.Files))
+```
+
+### Deleting a Snapshot
+
+To delete a snapshot:
+
+```go
+if err := ag.DeleteSnapshot(ctx, snapshotID); err != nil {
+    log.Fatalf("Failed to delete snapshot: %v", err)
+}
+```
+
+## API Reference
+
+### Agate
+
+The main entry point for the library.
+
+- `New(options AgateOptions) (*Agate, error)` - Create a new Agate instance
+- `SaveSnapshot(ctx context.Context, name string, parentID string) (string, error)` - Create a new snapshot
+- `RestoreSnapshot(ctx context.Context, snapshotID string) error` - Restore a snapshot
+- `ListSnapshots(ctx context.Context) ([]store.SnapshotInfo, error)` - List all snapshots
+- `GetSnapshotDetails(ctx context.Context, snapshotID string) (*store.Snapshot, error)` - Get details of a snapshot
+- `DeleteSnapshot(ctx context.Context, snapshotID string) error` - Delete a snapshot
+- `StartServer(ctx context.Context, address string) error` - Start a gRPC server to share snapshots
+- `ConnectRemote(address string) (*grpc.SnapshotClient, error)` - Connect to a remote server
+- `GetRemoteSnapshotList(ctx context.Context, address string) ([]store.SnapshotInfo, error)` - List snapshots from a remote server
+- `GetRemoteSnapshot(ctx context.Context, address string, snapshotID string, localParentID string) error` - Download a snapshot from a remote server
+
+### AgateOptions
+
+Configuration options for the Agate library.
+
+- `WorkDir string` - Directory where snapshots will be stored and managed
+- `OpenFunc func(dir string) error` - Called after a snapshot is restored
+- `CloseFunc func() error` - Called before a snapshot is created or restored
+- `MetadataStore store.MetadataStore` - Implementation of the metadata store
+- `BlobStore store.BlobStore` - Implementation of the blob store
+
+## License
+
+[Add your license information here]

api.go

@@ -4,11 +4,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"gitea.unprism.ru/KRBL/Agate/grpc"
 	"os"
 	"path/filepath"
-	"unprism.ru/KRBL/agate/grpc"
 
-	"unprism.ru/KRBL/agate/store"
+	"gitea.unprism.ru/KRBL/Agate/store"
 )
 
 // AgateOptions defines configuration options for the Agate library.
@@ -98,7 +98,7 @@ func New(options AgateOptions) (*Agate, error) {
 	}, nil
 }
 
-// SaveSnapshot creates a new snapshot from the current state of the work directory.
+// SaveSnapshot creates a new snapshot from the current state of the active directory.
 // If parentID is provided, it will be set as the parent of the new snapshot.
 // Returns the ID of the created snapshot.
 func (a *Agate) SaveSnapshot(ctx context.Context, name string, parentID string) (string, error) {
@@ -110,7 +110,7 @@ func (a *Agate) SaveSnapshot(ctx context.Context, name string, parentID string)
 	}
 
 	// Create the snapshot
-	snapshot, err := a.manager.CreateSnapshot(ctx, a.options.WorkDir, name, parentID)
+	snapshot, err := a.manager.CreateSnapshot(ctx, a.options.BlobStore.GetActiveDir(), name, parentID)
 	if err != nil {
 		return "", fmt.Errorf("failed to create snapshot: %w", err)
 	}
@@ -125,7 +125,7 @@ func (a *Agate) SaveSnapshot(ctx context.Context, name string, parentID string)
 	return snapshot.ID, nil
 }
 
-// RestoreSnapshot extracts a snapshot to the work directory.
+// RestoreSnapshot extracts a snapshot to the active directory.
 func (a *Agate) RestoreSnapshot(ctx context.Context, snapshotID string) error {
 	// Call CloseFunc if provided
 	if a.options.CloseFunc != nil {
@@ -135,13 +135,37 @@ func (a *Agate) RestoreSnapshot(ctx context.Context, snapshotID string) error {
 	}
 
 	// Extract the snapshot
-	if err := a.manager.ExtractSnapshot(ctx, snapshotID, a.options.WorkDir); err != nil {
+	if err := a.manager.ExtractSnapshot(ctx, snapshotID, a.options.BlobStore.GetActiveDir()); err != nil {
 		return fmt.Errorf("failed to extract snapshot: %w", err)
 	}
 
 	// Call OpenFunc if provided
 	if a.options.OpenFunc != nil {
-		if err := a.options.OpenFunc(a.options.WorkDir); err != nil {
+		if err := a.options.OpenFunc(a.options.BlobStore.GetActiveDir()); err != nil {
+			return fmt.Errorf("failed to open resources after restore: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// RestoreSnapshot extracts a snapshot to the directory.
+func (a *Agate) RestoreSnapshotToDir(ctx context.Context, snapshotID string, dir string) error {
+	// Call CloseFunc if provided
+	if a.options.CloseFunc != nil {
+		if err := a.options.CloseFunc(); err != nil {
+			return fmt.Errorf("failed to close resources before restore: %w", err)
+		}
+	}
+
+	// Extract the snapshot
+	if err := a.manager.ExtractSnapshot(ctx, snapshotID, dir); err != nil {
+		return fmt.Errorf("failed to extract snapshot: %w", err)
+	}
+
+	// Call OpenFunc if provided
+	if a.options.OpenFunc != nil {
+		if err := a.options.OpenFunc(dir); err != nil {
 			return fmt.Errorf("failed to open resources after restore: %w", err)
 		}
 	}

examples/basic_usage.go

@@ -7,8 +7,8 @@ import (
 	"os"
 	"path/filepath"
 
-	"unprism.ru/KRBL/agate"
-	"unprism.ru/KRBL/agate/stores"
+	"gitea.unprism.ru/KRBL/Agate"
+	"gitea.unprism.ru/KRBL/Agate/stores"
 )
 
 func main() {

go.mod

@@ -1,4 +1,4 @@
-module unprism.ru/KRBL/agate
+module gitea.unprism.ru/KRBL/Agate
 
 go 1.24.0
 
@@ -6,14 +6,14 @@ require (
 	github.com/google/uuid v1.6.0
 	github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.3
 	github.com/mattn/go-sqlite3 v1.14.28
-	google.golang.org/genproto/googleapis/api v0.0.0-20250422160041-2d3770c4ea7f
+	google.golang.org/genproto/googleapis/api v0.0.0-20250505200425-f936aa4a68b2
 	google.golang.org/grpc v1.72.0
 	google.golang.org/protobuf v1.36.6
 )
 
 require (
-	golang.org/x/net v0.39.0 // indirect
-	golang.org/x/sys v0.32.0 // indirect
-	golang.org/x/text v0.24.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20250422160041-2d3770c4ea7f // indirect
+	golang.org/x/net v0.40.0 // indirect
+	golang.org/x/sys v0.33.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250505200425-f936aa4a68b2 // indirect
 )

go.sum

@@ -26,14 +26,24 @@ go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC
 go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE=
 golang.org/x/net v0.39.0 h1:ZCu7HMWDxpXpaiKdhzIfaltL9Lp31x/3fCP11bc6/fY=
 golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20=
 golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0=
 golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 google.golang.org/genproto/googleapis/api v0.0.0-20250422160041-2d3770c4ea7f h1:tjZsroqekhC63+WMqzmWyW5Twj/ZfR5HAlpd5YQ1Vs0=
 google.golang.org/genproto/googleapis/api v0.0.0-20250422160041-2d3770c4ea7f/go.mod h1:Cd8IzgPo5Akum2c9R6FsXNaZbH3Jpa2gpHlW89FqlyQ=
+google.golang.org/genproto/googleapis/api v0.0.0-20250505200425-f936aa4a68b2 h1:vPV0tzlsK6EzEDHNNH5sa7Hs9bd7iXR7B1tSiPepkV0=
+google.golang.org/genproto/googleapis/api v0.0.0-20250505200425-f936aa4a68b2/go.mod h1:pKLAc5OolXC3ViWGI62vvC0n10CpwAtRcTNCFwTKBEw=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20250422160041-2d3770c4ea7f h1:N/PrbTw4kdkqNRzVfWPrBekzLuarFREcbFOiOLkXon4=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20250422160041-2d3770c4ea7f/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250505200425-f936aa4a68b2 h1:IqsN8hx+lWLqlN+Sc3DoMy/watjofWiU8sRFgQ8fhKM=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250505200425-f936aa4a68b2/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
 google.golang.org/grpc v1.72.0 h1:S7UkcVa60b5AAQTaO6ZKamFp1zMZSU0fGDK2WZLbBnM=
 google.golang.org/grpc v1.72.0/go.mod h1:wH5Aktxcg25y1I3w7H69nHfXdOG3UiadoBtjh3izSDM=
 google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=

grpc/client.go

@@ -10,7 +10,7 @@ import (
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 
-	"unprism.ru/KRBL/agate/store"
+	"gitea.unprism.ru/KRBL/Agate/store"
 )
 
 // SnapshotClient implements the client for connecting to a remote snapshot server

grpc/server.go

@@ -9,8 +9,8 @@ import (
 	"google.golang.org/grpc"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
-	"unprism.ru/KRBL/agate/interfaces"
-	"unprism.ru/KRBL/agate/store"
+	"gitea.unprism.ru/KRBL/Agate/interfaces"
+	"gitea.unprism.ru/KRBL/Agate/store"
 )
 
 // SnapshotServer implements the gRPC server for snapshots

grpc/snapshot.pb.go

@@ -476,7 +476,7 @@ const file_snapshot_proto_rawDesc = "" +
 	"\x0fSnapshotService\x12k\n" +
 	"\rListSnapshots\x12 .agate.grpc.ListSnapshotsRequest\x1a!.agate.grpc.ListSnapshotsResponse\"\x15\x82\xd3\xe4\x93\x02\x0f\x12\r/v1/snapshots\x12}\n" +
 	"\x12GetSnapshotDetails\x12%.agate.grpc.GetSnapshotDetailsRequest\x1a\x1b.agate.grpc.SnapshotDetails\"#\x82\xd3\xe4\x93\x02\x1d\x12\x1b/v1/snapshots/{snapshot_id}\x12\x8a\x01\n" +
-	"\fDownloadFile\x12\x1f.agate.grpc.DownloadFileRequest\x1a .agate.grpc.DownloadFileResponse\"5\x82\xd3\xe4\x93\x02/\x12-/v1/snapshots/{snapshot_id}/files/{file_path}0\x01B\x1cZ\x1aunprism.ru/KRBL/agate/grpcb\x06proto3"
+	"\fDownloadFile\x12\x1f.agate.grpc.DownloadFileRequest\x1a .agate.grpc.DownloadFileResponse\"5\x82\xd3\xe4\x93\x02/\x12-/v1/snapshots/{snapshot_id}/files/{file_path}0\x01B\"Z gitea.unprism.ru/KRBL/Agate/grpcb\x06proto3"
 
 var (
 	file_snapshot_proto_rawDescOnce sync.Once

grpc/snapshot.proto

@@ -5,7 +5,7 @@ package agate.grpc;
 import "google/protobuf/timestamp.proto";
 import "google/api/annotations.proto"; // Добавлено для HTTP mapping
 
-option go_package = "unprism.ru/KRBL/agate/grpc";
+option go_package = "gitea.unprism.ru/KRBL/Agate/grpc";
 
 // Сервис для управления снапшотами
 service SnapshotService {

interfaces/snapshot.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"io"
 
-	"unprism.ru/KRBL/agate/store"
+	"gitea.unprism.ru/KRBL/Agate/store"
 )
 
 // SnapshotManager defines the interface that the server needs to interact with snapshots

manager.go

@@ -13,9 +13,9 @@ import (
 
 	"github.com/google/uuid"
 
-	"unprism.ru/KRBL/agate/archive"
-	"unprism.ru/KRBL/agate/hash"
-	"unprism.ru/KRBL/agate/store"
+	"gitea.unprism.ru/KRBL/Agate/archive"
+	"gitea.unprism.ru/KRBL/Agate/hash"
+	"gitea.unprism.ru/KRBL/Agate/store"
 )
 
 type SnapshotManagerData struct {
@@ -59,12 +59,20 @@ func (data *SnapshotManagerData) CreateSnapshot(ctx context.Context, sourceDir s
 	// Generate a unique ID for the snapshot
 	snapshotID := uuid.New().String()
 
-	// Create a temporary file for the archive
-	tempFile, err := os.CreateTemp("", "agate-snapshot-*.zip")
-	if err != nil {
-		return nil, fmt.Errorf("failed to create temporary file: %w", err)
+	// Clean the active directory to avoid conflicts
+	if err := data.blobStore.CleanActiveDir(ctx); err != nil {
+		return nil, fmt.Errorf("failed to clean active directory: %w", err)
+	}
+
+	// Get the active directory for operations
+	activeDir := data.blobStore.GetActiveDir()
+
+	// Create a temporary file for the archive in the active directory
+	tempFilePath := filepath.Join(activeDir, "temp-"+snapshotID+".zip")
+	tempFile, err := os.Create(tempFilePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create temporary file in active directory: %w", err)
 	}
-	tempFilePath := tempFile.Name()
 	tempFile.Close()              // Close it as CreateArchive will reopen it
 	defer os.Remove(tempFilePath) // Clean up temp file after we're done
 
@@ -253,8 +261,15 @@ func (data *SnapshotManagerData) ExtractSnapshot(ctx context.Context, snapshotID
 	if snapshotID == "" {
 		return errors.New("snapshot ID cannot be empty")
 	}
+
+	// If no specific path is provided, use the active directory
 	if path == "" {
-		return errors.New("target path cannot be empty")
+		// Clean the active directory to avoid conflicts
+		if err := data.blobStore.CleanActiveDir(ctx); err != nil {
+			return fmt.Errorf("failed to clean active directory: %w", err)
+		}
+
+		path = filepath.Join(data.blobStore.GetActiveDir(), snapshotID)
 	}
 
 	// First check if the snapshot exists

remote/client.go

@@ -10,9 +10,9 @@ import (
 	stdgrpc "google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
 
-	agateGrpc "unprism.ru/KRBL/agate/grpc"
-	"unprism.ru/KRBL/agate/interfaces"
-	"unprism.ru/KRBL/agate/store"
+	agateGrpc "gitea.unprism.ru/KRBL/Agate/grpc"
+	"gitea.unprism.ru/KRBL/Agate/interfaces"
+	"gitea.unprism.ru/KRBL/Agate/store"
 )
 
 // Client represents a client for connecting to a remote snapshot server

remote/server.go

@@ -9,9 +9,9 @@ import (
 	stdgrpc "google.golang.org/grpc"
 	"google.golang.org/protobuf/types/known/timestamppb"
 
-	agateGrpc "unprism.ru/KRBL/agate/grpc"
-	"unprism.ru/KRBL/agate/interfaces"
-	"unprism.ru/KRBL/agate/store"
+	agateGrpc "gitea.unprism.ru/KRBL/Agate/grpc"
+	"gitea.unprism.ru/KRBL/Agate/interfaces"
+	"gitea.unprism.ru/KRBL/Agate/store"
 )
 
 // Server implements the gRPC server for snapshots

snapshot.go

@@ -2,8 +2,8 @@ package agate
 
 import (
 	"context"
+	"gitea.unprism.ru/KRBL/Agate/store"
 	"io"
-	"unprism.ru/KRBL/agate/store"
 )
 
 // SnapshotManager is an interface that defines operations for managing and interacting with snapshots.

store/filesystem/filesystem.go

@@ -3,27 +3,38 @@ package filesystem
 import (
 	"context"
 	"fmt"
+	"gitea.unprism.ru/KRBL/Agate"
+	"gitea.unprism.ru/KRBL/Agate/store"
 	"io"
 	"os"
 	"path/filepath"
-	"unprism.ru/KRBL/agate"
-	"unprism.ru/KRBL/agate/store"
 )
 
 const blobExtension = ".zip"
 
 // fileSystemStore реализует интерфейс store.BlobStore с использованием локальной файловой системы.
 type fileSystemStore struct {
-	baseDir string // Директория для хранения блобов (архивов)
+	baseDir   string // Директория для хранения блобов (архивов)
+	activeDir string // Директория для активных операций (создание и восстановление)
 }
 
 // NewFileSystemStore создает новое хранилище блобов в указанной директории.
 func NewFileSystemStore(baseDir string) (store.BlobStore, error) {
-	// Убедимся, что директория существует
+	// Убедимся, что базовая директория существует
 	if err := os.MkdirAll(baseDir, 0755); err != nil {
 		return nil, fmt.Errorf("failed to create base directory %s for filesystem blob store: %w", baseDir, err)
 	}
-	return &fileSystemStore{baseDir: baseDir}, nil
+
+	// Создаем директорию для активных операций внутри базовой директории
+	activeDir := filepath.Join(baseDir, "active")
+	if err := os.MkdirAll(activeDir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create active directory %s for filesystem blob store: %w", activeDir, err)
+	}
+
+	return &fileSystemStore{
+		baseDir:   baseDir,
+		activeDir: activeDir,
+	}, nil
 }
 
 // getBlobPath формирует полный путь к файлу блоба.
@@ -106,3 +117,27 @@ func (fs *fileSystemStore) GetBlobPath(ctx context.Context, snapshotID string) (
 	// Файл существует, возвращаем путь
 	return blobPath, nil
 }
+
+// GetActiveDir возвращает путь к директории для активных операций.
+func (fs *fileSystemStore) GetActiveDir() string {
+	return fs.activeDir
+}
+
+// CleanActiveDir очищает директорию для активных операций.
+// Это полезно перед началом новых операций, чтобы избежать конфликтов.
+func (fs *fileSystemStore) CleanActiveDir(ctx context.Context) error {
+	// Удаляем все файлы в активной директории, но сохраняем саму директорию
+	entries, err := os.ReadDir(fs.activeDir)
+	if err != nil {
+		return fmt.Errorf("failed to read active directory: %w", err)
+	}
+
+	for _, entry := range entries {
+		path := filepath.Join(fs.activeDir, entry.Name())
+		if err := os.RemoveAll(path); err != nil {
+			return fmt.Errorf("failed to remove %s from active directory: %w", path, err)
+		}
+	}
+
+	return nil
+}

store/sqlite/sqlite.go

@@ -6,12 +6,12 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"gitea.unprism.ru/KRBL/Agate"
+	"gitea.unprism.ru/KRBL/Agate/store"
 	_ "github.com/mattn/go-sqlite3"
 	"os"
 	"path/filepath"
 	"time"
-	"unprism.ru/KRBL/agate"
-	"unprism.ru/KRBL/agate/store"
 )
 
 const (

store/store.go

@@ -71,4 +71,11 @@ type BlobStore interface {
 	// Это может быть полезно для функций пакета archive, которые работают с путями.
 	// Возвращает agate.ErrNotFound, если блоб не найден.
 	GetBlobPath(ctx context.Context, snapshotID string) (string, error)
+
+	// GetActiveDir возвращает путь к директории для активных операций (создание и восстановление).
+	GetActiveDir() string
+
+	// CleanActiveDir очищает директорию для активных операций.
+	// Это полезно перед началом новых операций, чтобы избежать конфликтов.
+	CleanActiveDir(ctx context.Context) error
 }

stores/stores.go

@@ -4,9 +4,9 @@ import (
 	"fmt"
 	"path/filepath"
 
-	"unprism.ru/KRBL/agate/store"
-	"unprism.ru/KRBL/agate/store/filesystem"
-	"unprism.ru/KRBL/agate/store/sqlite"
+	"gitea.unprism.ru/KRBL/Agate/store"
+	"gitea.unprism.ru/KRBL/Agate/store/filesystem"
+	"gitea.unprism.ru/KRBL/Agate/store/sqlite"
 )
 
 // NewDefaultMetadataStore creates a new SQLite-based metadata store.
@@ -39,4 +39,4 @@ func InitDefaultStores(baseDir string) (store.MetadataStore, store.BlobStore, er
 	}
 
 	return metadataStore, blobStore, nil
-}
+}