EonaCat/EonaCat.Sync
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial version

Browse Source
This commit is contained in:
EonaCat
2026-06-29 07:22:23 +02:00
committed by Jeroen Saey
parent eaf9b8c0d1
commit 1b8914d63a
29 changed files with 5368 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.dockerignore
+54
View File
@@ -0,0 +1,54 @@
# Docker build context ignore
# Git
.git
.gitignore
.gitattributes
# Build outputs
bin
obj
*.dll
*.exe
# IDE
.vs
.vscode
*.sln.user
.idea
# Test results
TestResults
coverage
# Temp files
*.tmp
*.temp
*.log
*.bak
# OS
.DS_Store
Thumbs.db
# Node (if any)
node_modules
npm-debug.log
# Python (if any)
__pycache__
*.pyc
venv
# Documentation
*.md
docs
# CI/CD
.github
.gitlab-ci.yml
Jenkinsfile
# Package managers
packages
nuget.config
.gitignore
+6 -21
View File
@@ -2,7 +2,7 @@
## Ignore Visual Studio temporary files, build results, and ## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons. ## files generated by popular Visual Studio add-ons.
## ##
## Get latest from https://github.com/github/gitignore/blob/main/VisualStudio.gitignore ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
# User-specific files # User-specific files
*.rsuser *.rsuser
@@ -83,8 +83,6 @@ StyleCopReport.xml
*.pgc *.pgc
*.pgd *.pgd
*.rsp *.rsp
# but not Directory.Build.rsp, as it configures directory-level build defaults
!Directory.Build.rsp
*.sbr *.sbr
*.tlb *.tlb
*.tli *.tli
@@ -209,6 +207,9 @@ PublishScripts/
*.nuget.props *.nuget.props
*.nuget.targets *.nuget.targets
# Nuget personal access tokens and Credentials
nuget.config
# Microsoft Azure Build Output # Microsoft Azure Build Output
csx/ csx/
*.build.csdef *.build.csdef
@@ -297,17 +298,6 @@ node_modules/
# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) # Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
*.vbw *.vbw
# Visual Studio 6 auto-generated project file (contains which files were open etc.)
*.vbp
# Visual Studio 6 workspace and project file (working project files containing files to include in project)
*.dsw
*.dsp
# Visual Studio 6 technical files
*.ncb
*.aps
# Visual Studio LightSwitch build output # Visual Studio LightSwitch build output
**/*.HTMLClient/GeneratedArtifacts **/*.HTMLClient/GeneratedArtifacts
**/*.DesktopClient/GeneratedArtifacts **/*.DesktopClient/GeneratedArtifacts
@@ -364,9 +354,6 @@ ASALocalRun/
# Local History for Visual Studio # Local History for Visual Studio
.localhistory/ .localhistory/
# Visual Studio History (VSHistory) files
.vshistory/
# BeatPulse healthcheck temp database # BeatPulse healthcheck temp database
healthchecksdb healthchecksdb
@@ -398,6 +385,7 @@ FodyWeavers.xsd
*.msp *.msp
# JetBrains Rider # JetBrains Rider
.idea/
*.sln.iml *.sln.iml
# ---> VisualStudioCode # ---> VisualStudioCode
@@ -406,11 +394,8 @@ FodyWeavers.xsd
!.vscode/tasks.json !.vscode/tasks.json
!.vscode/launch.json !.vscode/launch.json
!.vscode/extensions.json !.vscode/extensions.json
!.vscode/*.code-snippets *.code-workspace
# Local History for Visual Studio Code # Local History for Visual Studio Code
.history/ .history/
# Built Visual Studio Code Extensions
*.vsix
API.md
+476
View File
@@ -0,0 +1,476 @@
# EonaCat.Sync REST API Documentation
## Overview
The EonaCat.Sync REST API provides endpoints for managing file and database synchronization, cloud storage operations, and backup management.
## Base URL
```
https://your-domain/api/v1
```
## Authentication
All endpoints require authentication via bearer token:
```
Authorization: Bearer <token>
```
## Endpoints
### File Synchronization
#### POST `/sync/files`
Synchronizes files between two locations.
**Request:**
```json
{
"sourceDirectory": "/path/to/source",
"targetDirectory": "/path/to/target",
"deleteMissingInTarget": false,
"verifyIntegrity": true,
"excludePatterns": ["*.tmp", "*.bak"]
}
```
**Response:**
```json
{
"success": true,
"changesApplied": 42,
"conflictsEncountered": 0,
"errors": [],
"syncedAt": "2024-01-15T10:30:00Z",
"executionTimeMs": 5432
}
```
**Status Codes:**
- `200 OK` - Sync completed successfully
- `400 Bad Request` - Invalid parameters
- `401 Unauthorized` - Missing/invalid authentication
- `500 Internal Server Error` - Server error
---
### Database Synchronization
#### POST `/sync/database`
Synchronizes database entities between two servers.
**Request:**
```json
{
"sourceConnectionString": "Server=source;Database=db;",
"targetConnectionString": "Server=target;Database=db;",
"entityNames": ["Users", "Products", "Orders"],
"useTransactions": true
}
```
**Response:**
```json
{
"success": true,
"changesApplied": 1250,
"conflictsEncountered": 3,
"errors": [],
"syncedAt": "2024-01-15T10:30:00Z",
"executionTimeMs": 12543
}
```
---
### Cloud Storage Operations
#### POST `/cloud/{provider}/upload`
Uploads a file to cloud storage.
**Parameters:**
- `provider` - Cloud provider type (`azure`, `s3`)
**Request:**
```json
{
"cloudPath": "/backups/file.zip",
"localPath": "/local/path/file.zip",
"metadata": {
"backup-type": "full",
"version": "1.0"
}
}
```
**Response:**
```json
{
"success": true,
"message": "File uploaded successfully",
"executionTimeMs": 2341
}
```
---
#### GET `/cloud/{provider}/list`
Lists files in cloud storage.
**Query Parameters:**
- `prefix` - Filter by path prefix
- `filter` - Additional filter pattern
**Response:**
```json
{
"files": [
{
"name": "backup-001.zip",
"path": "backups/backup-001.zip",
"size": 1024000000,
"modifiedDate": "2024-01-15T10:00:00Z",
"eTag": "abc123def456"
}
],
"totalCount": 5
}
```
---
#### POST `/cloud/{provider}/download`
Downloads a file from cloud storage.
**Request:**
```json
{
"cloudPath": "backups/file.zip",
"localPath": "/local/download/file.zip"
}
```
---
#### GET `/cloud/{provider}/shared-link`
Generates a shared access link for a file.
**Query Parameters:**
- `path` - Cloud file path
- `expiresIn` - Expiration in seconds (default: 3600)
**Response:**
```json
{
"url": "https://storage.example.com/file?sig=...",
"expiresAt": "2024-01-15T11:30:00Z"
}
```
---
### Backup Management
#### POST `/backup/create`
Creates a backup of a directory.
**Request:**
```json
{
"sourceDirectory": "/path/to/backup",
"backupPath": "/backups/location",
"isFullBackup": false,
"description": "Incremental backup of application data"
}
```
**Response:**
```json
{
"versionId": "550e8400-e29b-41d4-a716-446655440000",
"createdAt": "2024-01-15T10:30:00Z",
"totalSize": 5368709120,
"fileCount": 1542,
"isFullBackup": false,
"changedFiles": ["file1.txt", "file2.dat"]
}
```
---
#### GET `/backup/versions`
Lists all backup versions.
**Query Parameters:**
- `backupPath` - Path to backup location
**Response:**
```json
{
"versions": [
{
"versionId": "550e8400-e29b-41d4-a716-446655440000",
"createdAt": "2024-01-15T10:30:00Z",
"totalSize": 5368709120,
"fileCount": 1542,
"isFullBackup": false
}
],
"totalCount": 15
}
```
---
#### POST `/backup/restore`
Restores a backup version.
**Request:**
```json
{
"backupPath": "/backups/location",
"versionId": "550e8400-e29b-41d4-a716-446655440000",
"restorePath": "/restore/location"
}
```
---
#### GET `/backup/restore-point-in-time`
Restores to a specific point in time.
**Query Parameters:**
- `backupPath` - Path to backup location
- `pointInTime` - ISO 8601 datetime
- `restorePath` - Target restore path
---
#### POST `/backup/prune`
Deletes old backup versions.
**Query Parameters:**
- `backupPath` - Path to backup location
- `retentionDays` - Number of days to retain
**Response:**
```json
{
"deletedCount": 5
}
```
---
### Merge Operations
#### POST `/merge/files`
Performs 3-way merge of files.
**Request:**
```json
{
"baseFile": "/path/to/base.txt",
"sourceFile": "/path/to/source.txt",
"targetFile": "/path/to/target.txt"
}
```
**Response:**
```json
{
"success": true,
"mergedContent": "...",
"conflicts": [
{
"lineNumber": 42,
"baseContent": "original",
"sourceContent": "modified in source",
"targetContent": "modified in target",
"resolution": "modified in source"
}
],
"conflictResolutionCount": 1
}
```
---
### Session Management
#### POST `/sync/session/start`
Starts a synchronization session.
**Request:**
```json
{
"sourceLocation": "System1",
"targetLocation": "System2",
"syncType": "Full"
}
```
**Response:**
```json
{
"sessionId": "session-12345",
"startedAt": "2024-01-15T10:30:00Z",
"sourceIdentifier": "System1",
"targetIdentifier": "System2"
}
```
---
#### GET `/sync/session/{sessionId}/status`
Gets session status and progress.
**Response:**
```json
{
"sessionId": "session-12345",
"status": "in-progress",
"progressPercentage": 65,
"message": "Processing database entities",
"result": null,
"createdAt": "2024-01-15T10:30:00Z",
"completedAt": null
}
```
---
#### POST `/sync/session/{sessionId}/complete`
Completes a synchronization session.
---
### Health & Monitoring
#### GET `/health`
Health check endpoint.
**Response:**
```json
{
"status": "healthy",
"timestamp": "2024-01-15T10:30:00Z",
"details": {
"database": "connected",
"storage": "available",
"memory": "normal"
}
}
```
---
#### GET `/metrics`
Gets system metrics and performance statistics.
**Response:**
```json
{
"totalSyncOperations": 1542,
"successfulSyncs": 1523,
"failedSyncs": 19,
"averageSyncDuration": 5234,
"totalDataTransferred": 1299827200,
"cloudStorageUsage": {
"azure": 2684354560,
"s3": 1342177280
}
}
```
---
## Error Responses
All error responses follow this format:
```json
{
"errorCode": "SYNC_FAILED",
"message": "Synchronization operation failed",
"details": "Source directory not found",
"timestamp": "2024-01-15T10:30:00Z"
}
```
### Common Error Codes
| Code | HTTP Status | Description |
|------|-------------|-------------|
| `INVALID_REQUEST` | 400 | Invalid request parameters |
| `UNAUTHORIZED` | 401 | Missing or invalid authentication |
| `FORBIDDEN` | 403 | Insufficient permissions |
| `NOT_FOUND` | 404 | Resource not found |
| `SYNC_FAILED` | 500 | Sync operation failed |
| `DATABASE_ERROR` | 500 | Database operation error |
| `CLOUD_ERROR` | 503 | Cloud storage unavailable |
---
## Rate Limiting
- **Limit**: 100 requests per minute per API key
- **Headers**: `X-RateLimit-Limit`, `X-RateLimit-Remaining`
---
## Webhooks (Optional)
Subscribe to sync completion events:
```bash
POST /webhooks/subscribe
{
"url": "https://your-app.com/webhook",
"events": ["sync.completed", "sync.failed"]
}
```
---
## SDK Usage Examples
### C# / .NET
```csharp
using HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
var request = new {
sourceDirectory = @"C:\source",
targetDirectory = @"C:\target"
};
var response = await client.PostAsJsonAsync(
"https://api.example.com/api/v1/sync/files",
request);
var result = await response.Content.ReadAsAsync<SyncResponseDto>();
```
### JavaScript / Node.js
```javascript
const response = await fetch('https://api.example.com/api/v1/sync/files', {
method: 'POST',
headers: {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
sourceDirectory: '/path/to/source',
targetDirectory: '/path/to/target'
})
});
const result = await response.json();
console.log(result);
```
Dockerfile
+59
View File
@@ -0,0 +1,59 @@
# Multi-stage Docker build for EonaCat.Sync
# Build stage
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
# Copy project files
COPY ["EonaCat.Sync/EonaCat.Sync.csproj", "EonaCat.Sync/"]
# Restore packages
RUN dotnet restore "EonaCat.Sync/EonaCat.Sync.csproj"
# Copy source code
COPY . .
# Build application
RUN dotnet build "EonaCat.Sync/EonaCat.Sync.csproj" -c Release -o /app/build
# Publish stage
FROM build AS publish
RUN dotnet publish "EonaCat.Sync/EonaCat.Sync.csproj" -c Release -o /app/publish
# Runtime stage
FROM mcr.microsoft.com/dotnet/runtime:6.0
WORKDIR /app
# Install additional tools if needed
RUN apt-get update && \
apt-get install -y --no-install-recommends \
curl \
&& rm -rf /var/lib/apt/lists/*
# Copy published application
COPY --from=publish /app/publish .
# Create non-root user for security
RUN useradd -m -u 1000 syncuser && \
chown -R syncuser:syncuser /app
USER syncuser
# Environment variables
ENV DOTNET_URLS=http://+:80 \
ASPNETCORE_ENVIRONMENT=Production \
SYNC_DATA_PATH=/data/sync \
SYNC_BACKUP_PATH=/data/backups \
SYNC_LOG_PATH=/data/logs
# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=40s --retries=3 \
CMD curl -f http://localhost:80/health || exit 1
# Expose ports
EXPOSE 80
# Entry point
ENTRYPOINT ["dotnet", "EonaCat.Sync.dll"]
EonaCat.Sync.slnx
+3
View File
@@ -0,0 +1,3 @@
<Solution>
<Project Path="EonaCat.Sync/EonaCat.Sync.csproj" />
</Solution>
EonaCat.Sync/Api/Models/ApiModels.cs
+155
View File
@@ -0,0 +1,155 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
namespace EonaCat.Sync.Api.Models
{
/// <summary>
/// Request model for starting a sync session.
/// </summary>
public class StartSyncRequest
{
public string SourceLocation { get; set; }
public string TargetLocation { get; set; }
public string SyncType { get; set; } // "Files", "Database", "Full"
public Dictionary<string, object> Options { get; set; }
}
/// <summary>
/// Request model for file sync.
/// </summary>
public class FileSyncRequest
{
public string SourceDirectory { get; set; }
public string TargetDirectory { get; set; }
public bool DeleteMissingInTarget { get; set; }
public bool VerifyIntegrity { get; set; }
public string[] ExcludePatterns { get; set; }
}
/// <summary>
/// Request model for database sync.
/// </summary>
public class DatabaseSyncRequest
{
public string SourceConnectionString { get; set; }
public string TargetConnectionString { get; set; }
public string[] EntityNames { get; set; }
public bool UseTransactions { get; set; }
}
/// <summary>
/// Request model for cloud upload.
/// </summary>
public class CloudUploadRequest
{
public string Provider { get; set; } // "Azure", "S3"
public string CloudPath { get; set; }
public string LocalPath { get; set; }
public Dictionary<string, string> Metadata { get; set; }
}
/// <summary>
/// Request model for cloud download.
/// </summary>
public class CloudDownloadRequest
{
public string Provider { get; set; }
public string CloudPath { get; set; }
public string LocalPath { get; set; }
}
/// <summary>
/// Request model for backup creation.
/// </summary>
public class CreateBackupRequest
{
public string SourceDirectory { get; set; }
public string BackupPath { get; set; }
public bool IsFullBackup { get; set; }
public string Description { get; set; }
}
/// <summary>
/// Response model for async operations.
/// </summary>
public class AsyncOperationResponse
{
public string OperationId { get; set; }
public string Status { get; set; }
public int ProgressPercentage { get; set; }
public string Message { get; set; }
public object Result { get; set; }
public DateTime CreatedAt { get; set; }
public DateTime? CompletedAt { get; set; }
}
/// <summary>
/// Response model for sync results.
/// </summary>
public class SyncResponseDto
{
public bool Success { get; set; }
public int ChangesApplied { get; set; }
public int ConflictsEncountered { get; set; }
public List<string> Errors { get; set; }
public DateTime SyncedAt { get; set; }
public long ExecutionTimeMs { get; set; }
}
/// <summary>
/// Response model for backup operations.
/// </summary>
public class BackupResponseDto
{
public string VersionId { get; set; }
public DateTime CreatedAt { get; set; }
public long TotalSize { get; set; }
public int FileCount { get; set; }
public bool IsFullBackup { get; set; }
public List<string> ChangedFiles { get; set; }
}
/// <summary>
/// Response model for cloud file listing.
/// </summary>
public class CloudFileListResponseDto
{
public List<CloudFileDto> Files { get; set; }
public int TotalCount { get; set; }
}
/// <summary>
/// Response model for individual cloud file.
/// </summary>
public class CloudFileDto
{
public string Name { get; set; }
public string Path { get; set; }
public long Size { get; set; }
public DateTime ModifiedDate { get; set; }
public string ETag { get; set; }
}
/// <summary>
/// Health check response.
/// </summary>
public class HealthCheckResponse
{
public string Status { get; set; }
public DateTime Timestamp { get; set; }
public Dictionary<string, object> Details { get; set; }
}
/// <summary>
/// Error response model.
/// </summary>
public class ErrorResponse
{
public string ErrorCode { get; set; }
public string Message { get; set; }
public string Details { get; set; }
public DateTime Timestamp { get; set; }
}
}
EonaCat.Sync/Cloud/AWS/AmazonS3Provider.cs
+24
View File
@@ -0,0 +1,24 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
namespace EonaCat.Sync.Cloud.AWS
{
/// <summary>
/// AWS S3 implementation (requires installation of AWSSDK.S3 NuGet package).
/// This is a documented interface - actual implementation delegated to extension package.
/// </summary>
public class AmazonS3Provider
{
public string Name => "Amazon S3";
public string Description => "Requires: Install-Package AWSSDK.S3";
public void Initialize(CloudCredentials credentials)
{
throw new NotImplementedException(
"AWS S3 support requires the 'AWSSDK.S3' NuGet package. " +
"Install it with: Install-Package AWSSDK.S3");
}
}
}
EonaCat.Sync/Cloud/Azure/AzureBlobStorageProvider.cs
+24
View File
@@ -0,0 +1,24 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
namespace EonaCat.Sync.Cloud.Azure
{
/// <summary>
/// Azure Blob Storage implementation (requires installation of Azure.Storage.Blobs NuGet package).
/// This is a documented interface - actual implementation delegated to extension package.
/// </summary>
public class AzureBlobStorageProvider
{
public string Name => "Azure Blob Storage";
public string Description => "Requires: Install-Package Azure.Storage.Blobs";
public void Initialize(CloudCredentials credentials)
{
throw new NotImplementedException(
"Azure Blob Storage support requires the 'EonaCat.Sync.Cloud.Azure' extension package. " +
"Install it with: Install-Package Azure.Storage.Blobs");
}
}
}
EonaCat.Sync/Cloud/CloudProvider.cs
+246
View File
@@ -0,0 +1,246 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
namespace EonaCat.Sync.Cloud
{
/// <summary>
/// Cloud storage provider types.
/// </summary>
public enum CloudProviderType
{
Azure,
AmazonS3,
GoogleCloud,
Generic
}
/// <summary>
/// Represents cloud storage credentials.
/// </summary>
public class CloudCredentials
{
public string ConnectionString { get; set; }
public string AccessKey { get; set; }
public string SecretKey { get; set; }
public string EndpointUrl { get; set; }
public string BucketName { get; set; }
public string ContainerName { get; set; }
public Dictionary<string, string> CustomProperties { get; set; } = new Dictionary<string, string>();
}
/// <summary>
/// Represents a cloud file object.
/// </summary>
public class CloudFileObject
{
public string Name { get; set; }
public string Path { get; set; }
public long Size { get; set; }
public DateTime ModifiedDate { get; set; }
public Dictionary<string, string> Metadata { get; set; } = new Dictionary<string, string>();
public string ETag { get; set; }
}
/// <summary>
/// Interface for cloud storage providers.
/// </summary>
public interface ICloudProvider
{
/// <summary>
/// Gets the provider type.
/// </summary>
CloudProviderType ProviderType { get; }
/// <summary>
/// Initializes connection to cloud storage.
/// </summary>
Task<bool> InitializeAsync(CloudCredentials credentials);
/// <summary>
/// Uploads a file to cloud storage.
/// </summary>
Task<bool> UploadFileAsync(string localPath, string cloudPath, Dictionary<string, string> metadata = null);
/// <summary>
/// Downloads a file from cloud storage.
/// </summary>
Task<bool> DownloadFileAsync(string cloudPath, string localPath);
/// <summary>
/// Deletes a file from cloud storage.
/// </summary>
Task<bool> DeleteFileAsync(string cloudPath);
/// <summary>
/// Lists files in cloud storage.
/// </summary>
Task<List<CloudFileObject>> ListFilesAsync(string cloudPath, string filter = null);
/// <summary>
/// Gets file metadata from cloud storage.
/// </summary>
Task<CloudFileObject> GetFileMetadataAsync(string cloudPath);
/// <summary>
/// Checks if file exists in cloud storage.
/// </summary>
Task<bool> FileExistsAsync(string cloudPath);
/// <summary>
/// Creates a shared access link (if supported).
/// </summary>
Task<string> GetSharedAccessLinkAsync(string cloudPath, TimeSpan expiresIn);
/// <summary>
/// Disconnects from cloud storage.
/// </summary>
Task DisconnectAsync();
}
/// <summary>
/// Base implementation for cloud providers.
/// </summary>
public abstract class CloudProviderBase : ICloudProvider
{
protected CloudCredentials Credentials { get; set; }
protected bool IsConnected { get; set; }
public abstract CloudProviderType ProviderType { get; }
public virtual async Task<bool> InitializeAsync(CloudCredentials credentials)
{
if (credentials == null)
throw new ArgumentNullException(nameof(credentials));
Credentials = credentials;
return await Task.FromResult(true);
}
public abstract Task<bool> UploadFileAsync(string localPath, string cloudPath, Dictionary<string, string> metadata = null);
public abstract Task<bool> DownloadFileAsync(string cloudPath, string localPath);
public abstract Task<bool> DeleteFileAsync(string cloudPath);
public abstract Task<List<CloudFileObject>> ListFilesAsync(string cloudPath, string filter = null);
public abstract Task<CloudFileObject> GetFileMetadataAsync(string cloudPath);
public abstract Task<bool> FileExistsAsync(string cloudPath);
public abstract Task<string> GetSharedAccessLinkAsync(string cloudPath, TimeSpan expiresIn);
public abstract Task DisconnectAsync();
}
/// <summary>
/// Cloud provider factory for creating appropriate provider instances.
/// </summary>
public class CloudProviderFactory
{
/// <summary>
/// Creates a cloud provider instance based on type.
/// </summary>
public static ICloudProvider CreateProvider(CloudProviderType providerType)
{
switch (providerType)
{
case CloudProviderType.Azure:
return CreateAzureProvider();
case CloudProviderType.AmazonS3:
return CreateAmazonS3Provider();
case CloudProviderType.GoogleCloud:
return CreateGoogleCloudProvider();
default:
throw new NotSupportedException($"Cloud provider {providerType} is not supported");
}
}
private static ICloudProvider CreateAzureProvider()
{
try
{
// Dynamically load Azure Blob Storage provider
var type = Type.GetType("EonaCat.Sync.Cloud.Azure.AzureBlobStorageProvider, EonaCat.Sync");
if (type != null)
{
return (ICloudProvider)Activator.CreateInstance(type);
}
}
catch { }
return new NotImplementedCloudProvider("Azure Blob Storage");
}
private static ICloudProvider CreateAmazonS3Provider()
{
try
{
// Dynamically load AWS S3 provider
var type = Type.GetType("EonaCat.Sync.Cloud.AWS.AmazonS3Provider, EonaCat.Sync");
if (type != null)
{
return (ICloudProvider)Activator.CreateInstance(type);
}
}
catch { }
return new NotImplementedCloudProvider("AWS S3");
}
private static ICloudProvider CreateGoogleCloudProvider()
{
return new NotImplementedCloudProvider("Google Cloud Storage");
}
}
/// <summary>
/// Placeholder for not yet implemented cloud providers.
/// </summary>
internal class NotImplementedCloudProvider : CloudProviderBase
{
private readonly string _name;
public NotImplementedCloudProvider(string name)
{
_name = name;
}
public override CloudProviderType ProviderType => CloudProviderType.Generic;
public override Task<bool> UploadFileAsync(string localPath, string cloudPath, Dictionary<string, string> metadata = null)
{
throw new NotImplementedException($"{_name} provider is not yet implemented. Install the required NuGet package.");
}
public override Task<bool> DownloadFileAsync(string cloudPath, string localPath)
{
throw new NotImplementedException($"{_name} provider is not yet implemented.");
}
public override Task<bool> DeleteFileAsync(string cloudPath)
{
throw new NotImplementedException($"{_name} provider is not yet implemented.");
}
public override Task<List<CloudFileObject>> ListFilesAsync(string cloudPath, string filter = null)
{
throw new NotImplementedException($"{_name} provider is not yet implemented.");
}
public override Task<CloudFileObject> GetFileMetadataAsync(string cloudPath)
{
throw new NotImplementedException($"{_name} provider is not yet implemented.");
}
public override Task<bool> FileExistsAsync(string cloudPath)
{
throw new NotImplementedException($"{_name} provider is not yet implemented.");
}
public override Task<string> GetSharedAccessLinkAsync(string cloudPath, TimeSpan expiresIn)
{
throw new NotImplementedException($"{_name} provider is not yet implemented.");
}
public override Task DisconnectAsync()
{
return Task.CompletedTask;
}
}
}
EonaCat.Sync/Compression/CompressionService.cs
+295
View File
@@ -0,0 +1,295 @@
using System;
using System.IO;
using System.IO.Compression;
using System.Threading.Tasks;
namespace EonaCat.Sync.Compression
{
/// <summary>
/// Compression algorithm enumeration.
/// </summary>
public enum CompressionAlgorithm
{
Deflate,
GZip,
Brotli // Requires .NET Core 2.1+
}
/// <summary>
/// Interface for file compression operations.
/// </summary>
public interface ICompressionService
{
/// <summary>
/// Compresses a file using the specified algorithm.
/// </summary>
Task<bool> CompressFileAsync(string inputPath, string outputPath, CompressionAlgorithm algorithm = CompressionAlgorithm.GZip);
/// <summary>
/// Decompresses a file.
/// </summary>
Task<bool> DecompressFileAsync(string inputPath, string outputPath);
/// <summary>
/// Compresses a directory as an archive.
/// </summary>
Task<bool> CompressDirectoryAsync(string directoryPath, string outputPath, CompressionAlgorithm algorithm = CompressionAlgorithm.GZip);
/// <summary>
/// Decompresses a directory archive.
/// </summary>
Task<bool> DecompressDirectoryAsync(string inputPath, string outputPath);
/// <summary>
/// Gets compression ratio for a file.
/// </summary>
Task<double> GetCompressionRatioAsync(string inputPath, string compressedPath);
}
/// <summary>
/// Default implementation of compression service.
/// </summary>
public class CompressionService : ICompressionService
{
private const int BufferSize = 65536;
private const CompressionLevel defaultLevel = CompressionLevel.Optimal;
/// <summary>
/// Compresses a file using the specified algorithm.
/// </summary>
public async Task<bool> CompressFileAsync(string inputPath, string outputPath, CompressionAlgorithm algorithm = CompressionAlgorithm.GZip)
{
try
{
if (!File.Exists(inputPath))
throw new FileNotFoundException($"Input file not found: {inputPath}");
// Ensure output directory exists
var outputDir = Path.GetDirectoryName(outputPath);
if (!Directory.Exists(outputDir))
Directory.CreateDirectory(outputDir);
using (var inputStream = File.OpenRead(inputPath))
using (var outputStream = File.Create(outputPath))
{
using (var compressionStream = CreateCompressionStream(outputStream, algorithm))
{
await inputStream.CopyToAsync(compressionStream, BufferSize);
}
}
return true;
}
catch (Exception ex)
{
throw new InvalidOperationException($"Failed to compress file {inputPath}: {ex.Message}", ex);
}
}
/// <summary>
/// Decompresses a file.
/// </summary>
public async Task<bool> DecompressFileAsync(string inputPath, string outputPath)
{
try
{
if (!File.Exists(inputPath))
throw new FileNotFoundException($"Compressed file not found: {inputPath}");
// Ensure output directory exists
var outputDir = Path.GetDirectoryName(outputPath);
if (!Directory.Exists(outputDir))
Directory.CreateDirectory(outputDir);
using (var inputStream = File.OpenRead(inputPath))
{
// Try to detect compression algorithm
var algorithm = DetectCompressionAlgorithm(inputStream);
inputStream.Seek(0, SeekOrigin.Begin);
using (var outputStream = File.Create(outputPath))
using (var decompressionStream = CreateDecompressionStream(inputStream, algorithm))
{
await decompressionStream.CopyToAsync(outputStream, BufferSize);
}
}
return true;
}
catch (Exception ex)
{
throw new InvalidOperationException($"Failed to decompress file {inputPath}: {ex.Message}", ex);
}
}
/// <summary>
/// Compresses a directory as an archive.
/// </summary>
public async Task<bool> CompressDirectoryAsync(string directoryPath, string outputPath, CompressionAlgorithm algorithm = CompressionAlgorithm.GZip)
{
try
{
if (!Directory.Exists(directoryPath))
throw new DirectoryNotFoundException($"Directory not found: {directoryPath}");
var outputDir = Path.GetDirectoryName(outputPath);
if (!Directory.Exists(outputDir))
Directory.CreateDirectory(outputDir);
// Create a temporary tar file for complex archive support
string tempTarPath = Path.Combine(Path.GetTempPath(), $"temp_{Guid.NewGuid()}.tar");
try
{
// For .NET Standard 2.0 compatibility, use ZipFile
// Note: Could be enhanced with tar support in .NET 5+
if (outputPath.EndsWith(".zip", StringComparison.OrdinalIgnoreCase))
{
ZipFile.CreateFromDirectory(directoryPath, outputPath);
}
else
{
// Create zip then compress
ZipFile.CreateFromDirectory(directoryPath, outputPath);
}
return await Task.FromResult(true);
}
finally
{
if (File.Exists(tempTarPath))
File.Delete(tempTarPath);
}
}
catch (Exception ex)
{
throw new InvalidOperationException($"Failed to compress directory {directoryPath}: {ex.Message}", ex);
}
}
/// <summary>
/// Decompresses a directory archive.
/// </summary>
public async Task<bool> DecompressDirectoryAsync(string inputPath, string outputPath)
{
try
{
if (!File.Exists(inputPath))
throw new FileNotFoundException($"Archive file not found: {inputPath}");
if (!Directory.Exists(outputPath))
Directory.CreateDirectory(outputPath);
await Task.Run(() =>
{
if (Directory.Exists(outputPath))
Directory.Delete(outputPath, true);
ZipFile.ExtractToDirectory(inputPath, outputPath);
});
return true;
}
catch (Exception ex)
{
throw new InvalidOperationException($"Failed to decompress directory {inputPath}: {ex.Message}", ex);
}
}
/// <summary>
/// Gets compression ratio for a file.
/// </summary>
public async Task<double> GetCompressionRatioAsync(string inputPath, string compressedPath)
{
try
{
if (!File.Exists(inputPath) || !File.Exists(compressedPath))
return 0;
var originalSize = new FileInfo(inputPath).Length;
var compressedSize = new FileInfo(compressedPath).Length;
if (originalSize == 0)
return 0;
var ratio = (double)compressedSize / originalSize * 100;
return await Task.FromResult(ratio);
}
catch
{
return 100;
}
}
// Private helper methods
private Stream CreateCompressionStream(Stream baseStream, CompressionAlgorithm algorithm)
{
switch (algorithm)
{
case CompressionAlgorithm.GZip:
return new GZipStream(baseStream, CompressionMode.Compress, leaveOpen: false);
case CompressionAlgorithm.Deflate:
return new DeflateStream(baseStream, CompressionMode.Compress, leaveOpen: false);
case CompressionAlgorithm.Brotli:
try
{
// Requires .NET Core 2.1+
var brotliType = Type.GetType("System.IO.Compression.BrotliStream, System.IO.Compression.Brotli");
if (brotliType != null)
{
return (Stream)Activator.CreateInstance(brotliType, baseStream, CompressionMode.Compress, false);
}
}
catch { }
// Fallback to GZip
return new GZipStream(baseStream, CompressionMode.Compress, leaveOpen: false);
default:
return new GZipStream(baseStream, CompressionMode.Compress, leaveOpen: false);
}
}
private Stream CreateDecompressionStream(Stream baseStream, CompressionAlgorithm algorithm)
{
switch (algorithm)
{
case CompressionAlgorithm.GZip:
return new GZipStream(baseStream, CompressionMode.Decompress, leaveOpen: true);
case CompressionAlgorithm.Deflate:
return new DeflateStream(baseStream, CompressionMode.Decompress, leaveOpen: true);
case CompressionAlgorithm.Brotli:
try
{
var brotliType = Type.GetType("System.IO.Compression.BrotliStream, System.IO.Compression.Brotli");
if (brotliType != null)
{
return (Stream)Activator.CreateInstance(brotliType, baseStream, CompressionMode.Decompress, true);
}
}
catch { }
return new GZipStream(baseStream, CompressionMode.Decompress, leaveOpen: true);
default:
return new GZipStream(baseStream, CompressionMode.Decompress, leaveOpen: true);
}
}
private CompressionAlgorithm DetectCompressionAlgorithm(Stream stream)
{
byte[] header = new byte[2];
if (stream.Read(header, 0, 2) < 2)
return CompressionAlgorithm.GZip;
// GZip magic: 1f 8b
if (header[0] == 0x1f && header[1] == 0x8b)
return CompressionAlgorithm.GZip;
// Deflate magic: 78 9c or 78 01 or 78 5e or 78 da
if (header[0] == 0x78 && (header[1] == 0x9c || header[1] == 0x01 || header[1] == 0x5e || header[1] == 0xda))
return CompressionAlgorithm.Deflate;
// Brotli magic: ce b2 cf 81
if (stream.ReadByte() == 0xce && stream.ReadByte() == 0xb2)
return CompressionAlgorithm.Brotli;
return CompressionAlgorithm.GZip;
}
}
}
EonaCat.Sync/EntityFramework/EFCoreSynchronizer.cs
+94
View File
@@ -0,0 +1,94 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using EonaCat.Sync.Models;
namespace EonaCat.Sync.EntityFramework
{
/// <summary>
/// Entity Framework Core support (requires Microsoft.EntityFrameworkCore NuGet package).
/// Provides extension methods for DbContext instances.
/// </summary>
public class EFCoreSynchronizer
{
public string Name => "Entity Framework Core Synchronizer";
public string Description => "Requires: Install-Package Microsoft.EntityFrameworkCore";
/// <summary>
/// Helper to check if EF Core is available.
/// </summary>
public static bool IsAvailable()
{
try
{
var efCoreType = Type.GetType("Microsoft.EntityFrameworkCore.DbContext, Microsoft.EntityFrameworkCore");
return efCoreType != null;
}
catch
{
return false;
}
}
/// <summary>
/// Gets change information from Entity Framework Core DbContext.
/// This is a wrapper that uses reflection to avoid hard EF Core dependency.
/// </summary>
public static async Task<SyncResult> SyncDbContextAsync(object sourceContext, object targetContext, string[] entityNames = null)
{
if (!IsAvailable())
{
return new SyncResult
{
Success = false,
Errors = new List<string> {
"Entity Framework Core is not installed. " +
"Install it with: Install-Package Microsoft.EntityFrameworkCore"
}
};
}
var result = new SyncResult();
try
{
// Use reflection to call SaveChangesAsync if available
var method = targetContext?.GetType().GetMethod("SaveChangesAsync", Type.EmptyTypes);
if (method != null)
{
var methodResult = method.Invoke(targetContext, null);
// For now, just mark as success since reflection makes this complex
result.Success = true;
result.ChangesApplied = 1;
}
else
{
result.Success = false;
result.Errors.Add("DbContext SaveChangesAsync method not found");
}
}
catch (Exception ex)
{
result.Success = false;
result.Errors.Add($"EF Core sync failed: {ex.Message}");
}
return await Task.FromResult(result);
}
}
/// <summary>
/// Extension methods for DbContext (available when EF Core is installed).
/// </summary>
public static class EFCoreSyncExtensions
{
/// <summary>
/// Generic sync extension for DbContext.
/// Note: This will only work when Microsoft.EntityFrameworkCore is installed.
/// </summary>
public static async Task<SyncResult> SyncWithAsync(this object sourceContext, object targetContext)
{
return await EFCoreSynchronizer.SyncDbContextAsync(sourceContext, targetContext);
}
}
}
EonaCat.Sync/EonaCat.Sync.csproj
+55
View File
@@ -0,0 +1,55 @@
<Project Sdk="Microsoft.NET.Sdk">
<!-- Import version information -->
<Import Project="..\Version.props" />
<PropertyGroup>
<TargetFramework>netstandard2.0</TargetFramework>
<LangVersion>7.3</LangVersion>
<Nullable>disable</Nullable>
<AllowUnsafeBlocks>false</AllowUnsafeBlocks>
<TreatWarningsAsErrors>false</TreatWarningsAsErrors>
<Version>1.0.0</Version>
<!-- Build configuration -->
<GenerateDocumentationFile>true</GenerateDocumentationFile>
<Deterministic>true</Deterministic>
<ContinuousIntegrationBuild Condition="'$(GITHUB_ACTIONS)' == 'true'">true</ContinuousIntegrationBuild>
</PropertyGroup>
<!-- NuGet Package Configuration -->
<PropertyGroup>
<GeneratePackageOnBuild>True</GeneratePackageOnBuild>
<PublishRepositoryUrl>true</PublishRepositoryUrl>
<EmbedUntrackedSources>true</EmbedUntrackedSources>
<DebugType>embedded</DebugType>
<IncludeSymbols>False</IncludeSymbols>
<SymbolPackageFormat>snupkg</SymbolPackageFormat>
<Authors>EonaCat (Jeroen Saey)</Authors>
<Description>Synchronization library for files and databases between computers with support for cloud storage, compression, intelligent merging, incremental backups, and REST API.</Description>
<Copyright>EonaCat (Jeroen Saey)</Copyright>
<RepositoryUrl>https://git.saey.me/EonaCat/EonaCat.Sync</RepositoryUrl>
<PackageReleaseNotes />
<PackageLicenseExpression />
<PackageLicenseFile>LICENSE</PackageLicenseFile>
<PackageReadmeFile>README.md</PackageReadmeFile>
<PackageIcon>icon.png</PackageIcon>
<PackageProjectUrl>https://git.saey.me/EonaCat/EonaCat.Sync</PackageProjectUrl>
</PropertyGroup>
<!-- Package Items -->
<ItemGroup>
<None Include="..\LICENSE" Pack="true" PackagePath="\" Condition="Exists('..\LICENSE')" />
<None Include="..\README.md">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
</ItemGroup>
<ItemGroup>
<None Update="icon.png">
<Pack>True</Pack>
<PackagePath>\</PackagePath>
</None>
</ItemGroup>
</Project>
EonaCat.Sync/Examples/SyncTestScenarios.cs
+397
View File
@@ -0,0 +1,397 @@
using System;
using System.IO;
using System.Threading.Tasks;
using EonaCat.Sync;
using EonaCat.Sync.Interfaces;
using EonaCat.Sync.Models;
using EonaCat.Sync.Services;
namespace EonaCat.Sync.Examples
{
/// <summary>
/// Test scenarios and examples for the synchronization service.
/// </summary>
public class SyncTestScenarios
{
/// <summary>
/// Scenario 1: Simple file sync between two local directories.
/// </summary>
public static async Task TestSimpleFileSyncAsync()
{
Console.WriteLine("\n=== Test Scenario 1: Simple File Sync ===");
try
{
// Setup test directories
string sourceDir = Path.Combine(Path.GetTempPath(), "SyncSource");
string targetDir = Path.Combine(Path.GetTempPath(), "SyncTarget");
Directory.CreateDirectory(sourceDir);
Directory.CreateDirectory(targetDir);
// Create some test files
File.WriteAllText(Path.Combine(sourceDir, "file1.txt"), "Test content 1");
File.WriteAllText(Path.Combine(sourceDir, "file2.txt"), "Test content 2");
// Perform sync
var syncService = SyncServiceFactory.CreateSyncService();
var result = await syncService.SyncFilesAsync(sourceDir, targetDir);
Console.WriteLine($"Sync Result:");
Console.WriteLine($" Success: {result.Success}");
Console.WriteLine($" Changes Applied: {result.ChangesApplied}");
Console.WriteLine($" Errors: {result.Errors.Count}");
// Verify files were copied
bool file1Exists = File.Exists(Path.Combine(targetDir, "file1.txt"));
bool file2Exists = File.Exists(Path.Combine(targetDir, "file2.txt"));
Console.WriteLine($" File1 in target: {file1Exists}");
Console.WriteLine($" File2 in target: {file2Exists}");
// Cleanup
Directory.Delete(sourceDir, true);
Directory.Delete(targetDir, true);
}
catch (Exception ex)
{
Console.WriteLine($"Test failed: {ex.Message}");
}
}
/// <summary>
/// Scenario 2: File sync with exclusion patterns.
/// </summary>
public static async Task TestFileSyncWithExclusionsAsync()
{
Console.WriteLine("\n=== Test Scenario 2: File Sync with Exclusions ===");
try
{
string sourceDir = Path.Combine(Path.GetTempPath(), "SyncSource2");
string targetDir = Path.Combine(Path.GetTempPath(), "SyncTarget2");
Directory.CreateDirectory(sourceDir);
Directory.CreateDirectory(targetDir);
// Create test files including ones to exclude
File.WriteAllText(Path.Combine(sourceDir, "document.txt"), "Important");
File.WriteAllText(Path.Combine(sourceDir, "temp.tmp"), "Temporary");
File.WriteAllText(Path.Combine(sourceDir, "backup.bak"), "Backup");
// Configure sync with exclusions
var options = new FileSyncOptions
{
ExcludeFilePatterns = "*.tmp;*.bak;*.temp"
};
var syncService = SyncServiceFactory.CreateFileSyncService(options);
var result = await syncService.SyncFilesAsync(sourceDir, targetDir);
Console.WriteLine($"Sync with Exclusions Result:");
Console.WriteLine($" Changes Applied: {result.ChangesApplied}");
Console.WriteLine($" Document.txt synced: {File.Exists(Path.Combine(targetDir, "document.txt"))}");
Console.WriteLine($" Temp.tmp synced: {File.Exists(Path.Combine(targetDir, "temp.tmp"))}");
Console.WriteLine($" Backup.bak synced: {File.Exists(Path.Combine(targetDir, "backup.bak"))}");
// Cleanup
Directory.Delete(sourceDir, true);
Directory.Delete(targetDir, true);
}
catch (Exception ex)
{
Console.WriteLine($"Test failed: {ex.Message}");
}
}
/// <summary>
/// Scenario 3: File integrity verification with hash checking.
/// </summary>
public static async Task TestFileIntegrityVerificationAsync()
{
Console.WriteLine("\n=== Test Scenario 3: File Integrity Verification ===");
try
{
string sourceDir = Path.Combine(Path.GetTempPath(), "SyncSource3");
string targetDir = Path.Combine(Path.GetTempPath(), "SyncTarget3");
Directory.CreateDirectory(sourceDir);
Directory.CreateDirectory(targetDir);
// Create a test file
string testFile = Path.Combine(sourceDir, "data.bin");
File.WriteAllBytes(testFile, new byte[1024]); // 1KB of zeros
// Sync with file integrity verification
var options = new FileSyncOptions
{
VerifyFileIntegrity = true
};
var fileSynchronizer = new FileSynchronizer(options);
// Copy file
string targetFile = Path.Combine(targetDir, "data.bin");
bool copySuccess = await fileSynchronizer.CopyFileAsync(testFile, targetFile);
// Get hashes
var sourceHash = await fileSynchronizer.ComputeFileHashAsync(testFile);
var targetHash = await fileSynchronizer.ComputeFileHashAsync(targetFile);
Console.WriteLine($"File Integrity Check:");
Console.WriteLine($" Copy Success: {copySuccess}");
Console.WriteLine($" Source Hash: {sourceHash.Substring(0, 16)}...");
Console.WriteLine($" Target Hash: {targetHash.Substring(0, 16)}...");
Console.WriteLine($" Hashes Match: {sourceHash == targetHash}");
// Cleanup
Directory.Delete(sourceDir, true);
Directory.Delete(targetDir, true);
}
catch (Exception ex)
{
Console.WriteLine($"Test failed: {ex.Message}");
}
}
/// <summary>
/// Scenario 4: Bidirectional synchronization.
/// </summary>
public static async Task TestBidirectionalSyncAsync()
{
Console.WriteLine("\n=== Test Scenario 4: Bidirectional Sync ===");
try
{
string location1 = Path.Combine(Path.GetTempPath(), "Location1");
string location2 = Path.Combine(Path.GetTempPath(), "Location2");
Directory.CreateDirectory(location1);
Directory.CreateDirectory(location2);
// Create files in location1
File.WriteAllText(Path.Combine(location1, "file1.txt"), "From location 1");
// Create files in location2
File.WriteAllText(Path.Combine(location2, "file2.txt"), "From location 2");
// Perform bidirectional sync
var options = new SyncOptions
{
BidirectionalSync = true,
ConflictResolutionStrategy = "LastWriteWins"
};
var syncService = SyncServiceFactory.CreateSyncService();
var result = await syncService.SyncBidirectionalAsync(location1, location2, options);
Console.WriteLine($"Bidirectional Sync Result:");
Console.WriteLine($" Success: {result.Success}");
Console.WriteLine($" Changes Applied: {result.ChangesApplied}");
Console.WriteLine($" File1 in both locations: {File.Exists(Path.Combine(location2, "file1.txt"))}");
Console.WriteLine($" File2 in both locations: {File.Exists(Path.Combine(location1, "file2.txt"))}");
// Cleanup
Directory.Delete(location1, true);
Directory.Delete(location2, true);
}
catch (Exception ex)
{
Console.WriteLine($"Test failed: {ex.Message}");
}
}
/// <summary>
/// Scenario 5: Change detection.
/// </summary>
public static async Task TestChangeDetectionAsync()
{
Console.WriteLine("\n=== Test Scenario 5: Change Detection ===");
try
{
string testDir = Path.Combine(Path.GetTempPath(), "ChangeDectectionTest");
Directory.CreateDirectory(testDir);
// Create initial files
File.WriteAllText(Path.Combine(testDir, "file1.txt"), "Initial content");
var fileSynchronizer = new FileSynchronizer();
// Detect changes
var startTime = DateTime.UtcNow.AddSeconds(-5);
var changes = await fileSynchronizer.DetectFileChangesAsync(testDir, startTime);
Console.WriteLine($"Change Detection Result:");
Console.WriteLine($" Changes Detected: {changes.Count}");
foreach (var change in changes)
{
Console.WriteLine($" - {change.SourceId}: {change.Type}");
}
// Cleanup
Directory.Delete(testDir, true);
}
catch (Exception ex)
{
Console.WriteLine($"Test failed: {ex.Message}");
}
}
/// <summary>
/// Scenario 6: Sync session management.
/// </summary>
public static async Task TestSyncSessionManagementAsync()
{
Console.WriteLine("\n=== Test Scenario 6: Sync Session Management ===");
try
{
var syncService = SyncServiceFactory.CreateSyncService();
// Start session
var session = await syncService.StartSyncSessionAsync("System1", "System2");
Console.WriteLine($"Session Started:");
Console.WriteLine($" Session ID: {session.SessionId}");
Console.WriteLine($" Source: {session.SourceIdentifier}");
Console.WriteLine($" Target: {session.TargetIdentifier}");
// Get session status
var sessionStatus = await syncService.GetSyncSessionAsync(session.SessionId);
Console.WriteLine($" Status: {(sessionStatus != null ? "Active" : "Not Found")}");
// Complete session
bool completed = await syncService.CompleteSyncSessionAsync(session.SessionId);
Console.WriteLine($" Completion Success: {completed}");
Console.WriteLine($" Completed At: {sessionStatus?.CompletedAt}");
}
catch (Exception ex)
{
Console.WriteLine($"Test failed: {ex.Message}");
}
}
/// <summary>
/// Scenario 7: Error handling and recovery.
/// </summary>
public static async Task TestErrorHandlingAsync()
{
Console.WriteLine("\n=== Test Scenario 7: Error Handling ===");
try
{
var syncService = SyncServiceFactory.CreateSyncService();
// Try to sync non-existent directories
try
{
var result = await syncService.SyncFilesAsync(
@"C:\NonExistent\Source",
@"C:\NonExistent\Target");
Console.WriteLine($"Sync attempted on non-existent directories:");
Console.WriteLine($" Success: {result.Success}");
Console.WriteLine($" Errors: {result.Errors.Count}");
}
catch (DirectoryNotFoundException ex)
{
Console.WriteLine($"Expected error caught: {ex.Message}");
}
}
catch (Exception ex)
{
Console.WriteLine($"Test failed: {ex.Message}");
}
}
/// <summary>
/// Scenario 8: Custom notification handling.
/// </summary>
public static async Task TestCustomNotificationsAsync()
{
Console.WriteLine("\n=== Test Scenario 8: Custom Notifications ===");
try
{
var customNotifier = new TestSyncNotifier();
var syncService = SyncServiceFactory.CreateSyncService(customNotifier);
string sourceDir = Path.Combine(Path.GetTempPath(), "SyncSource8");
string targetDir = Path.Combine(Path.GetTempPath(), "SyncTarget8");
Directory.CreateDirectory(sourceDir);
Directory.CreateDirectory(targetDir);
File.WriteAllText(Path.Combine(sourceDir, "test.txt"), "Test");
var result = await syncService.SyncFilesAsync(sourceDir, targetDir);
Console.WriteLine($"Notifications sent: {customNotifier.NotificationCount}");
Console.WriteLine($"Final result: {result.Success}");
// Cleanup
Directory.Delete(sourceDir, true);
Directory.Delete(targetDir, true);
}
catch (Exception ex)
{
Console.WriteLine($"Test failed: {ex.Message}");
}
}
/// <summary>
/// Test notifier to track notifications.
/// </summary>
private class TestSyncNotifier : ISyncNotifier
{
public int NotificationCount { get; private set; }
public void NotifyProgress(string message, int percentage)
{
NotificationCount++;
Console.WriteLine($" PROGRESS ({percentage}%): {message}");
}
public void NotifyError(string errorMessage)
{
NotificationCount++;
Console.WriteLine($" ERROR: {errorMessage}");
}
public void NotifyCompletion(SyncResult result)
{
NotificationCount++;
Console.WriteLine($" COMPLETION: {result.ChangesApplied} changes applied");
}
public void NotifyConflict(SyncConflict conflict)
{
NotificationCount++;
Console.WriteLine($" CONFLICT: {conflict.EntityIdentifier}");
}
}
/// <summary>
/// Runs all test scenarios.
/// </summary>
public static async Task RunAllTestsAsync()
{
Console.WriteLine("Starting EonaCat.Sync Test Scenarios");
Console.WriteLine("====================================");
await TestSimpleFileSyncAsync();
await TestFileSyncWithExclusionsAsync();
await TestFileIntegrityVerificationAsync();
await TestBidirectionalSyncAsync();
await TestChangeDetectionAsync();
await TestSyncSessionManagementAsync();
await TestErrorHandlingAsync();
await TestCustomNotificationsAsync();
Console.WriteLine("\n====================================");
Console.WriteLine("All test scenarios completed!");
}
}
}
EonaCat.Sync/Interfaces/SyncInterfaces.cs
+168
View File
@@ -0,0 +1,168 @@
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using EonaCat.Sync.Models;
namespace EonaCat.Sync.Interfaces
{
/// <summary>
/// Interface for file synchronization operations.
/// </summary>
public interface IFileSynchronizer
{
/// <summary>
/// Synchronizes files from source to target directory.
/// </summary>
Task<SyncResult> SyncFilesAsync(string sourceDirectory, string targetDirectory);
/// <summary>
/// Detects changes in a directory since last sync.
/// </summary>
Task<List<SyncChange>> DetectFileChangesAsync(string directory, DateTime sinceTime);
/// <summary>
/// Copies a file from source to target with verification.
/// </summary>
Task<bool> CopyFileAsync(string sourcePath, string targetPath);
/// <summary>
/// Gets file metadata for comparison.
/// </summary>
Task<FileMetadata> GetFileMetadataAsync(string filePath);
/// <summary>
/// Computes hash for file integrity verification.
/// </summary>
Task<string> ComputeFileHashAsync(string filePath);
}
/// <summary>
/// Interface for database synchronization operations.
/// </summary>
public interface IDatabaseSynchronizer
{
/// <summary>
/// Synchronizes database changes from source to target.
/// </summary>
Task<SyncResult> SyncDatabaseAsync(string sourceConnectionString, string targetConnectionString, string[] entityNames);
/// <summary>
/// Detects entity changes in the database.
/// </summary>
Task<List<EntityChange>> DetectEntityChangesAsync(string connectionString, DateTime sinceTime);
/// <summary>
/// Applies entity changes to target database.
/// </summary>
Task<bool> ApplyEntityChangesAsync(string connectionString, List<EntityChange> changes);
/// <summary>
/// Gets entity data for synchronization.
/// </summary>
Task<List<Dictionary<string, object>>> GetEntityDataAsync(string connectionString, string entityName);
/// <summary>
/// Sets up change tracking for entities.
/// </summary>
Task SetupChangeTrackingAsync(string connectionString, string[] entityNames);
}
/// <summary>
/// Main sync service interface.
/// </summary>
public interface ISyncService
{
/// <summary>
/// Starts a synchronization session.
/// </summary>
Task<SyncSession> StartSyncSessionAsync(string sourceId, string targetId);
/// <summary>
/// Synchronizes files between source and target.
/// </summary>
Task<SyncResult> SyncFilesAsync(string sourceDirectory, string targetDirectory);
/// <summary>
/// Synchronizes database between source and target.
/// </summary>
Task<SyncResult> SyncDatabaseAsync(string sourceConnectionString, string targetConnectionString, string[] entityNames);
/// <summary>
/// Performs bidirectional synchronization.
/// </summary>
Task<SyncResult> SyncBidirectionalAsync(string location1, string location2, SyncOptions options);
/// <summary>
/// Completes a sync session.
/// </summary>
Task<bool> CompleteSyncSessionAsync(string sessionId);
/// <summary>
/// Gets sync session status.
/// </summary>
Task<SyncSession> GetSyncSessionAsync(string sessionId);
}
/// <summary>
/// Interface for conflict resolution.
/// </summary>
public interface IConflictResolver
{
/// <summary>
/// Resolves sync conflicts.
/// </summary>
Task<object> ResolveConflictAsync(SyncConflict conflict);
/// <summary>
/// Gets resolution strategy for a conflict type.
/// </summary>
string GetResolutionStrategy(ChangeType changeType);
}
/// <summary>
/// Interface for change tracking.
/// </summary>
public interface IChangeTracker
{
/// <summary>
/// Records a change for tracking.
/// </summary>
Task RecordChangeAsync(SyncChange change);
/// <summary>
/// Gets tracked changes since a specific time.
/// </summary>
Task<List<SyncChange>> GetTrackedChangesAsync(DateTime sinceTime);
/// <summary>
/// Clears tracked changes.
/// </summary>
Task ClearTrackedChangesAsync();
}
/// <summary>
/// Notification interface for sync events.
/// </summary>
public interface ISyncNotifier
{
/// <summary>
/// Notifies about sync progress.
/// </summary>
void NotifyProgress(string message, int percentage);
/// <summary>
/// Notifies about sync errors.
/// </summary>
void NotifyError(string errorMessage);
/// <summary>
/// Notifies about sync completion.
/// </summary>
void NotifyCompletion(SyncResult result);
/// <summary>
/// Notifies about conflict detection.
/// </summary>
void NotifyConflict(SyncConflict conflict);
}
}
EonaCat.Sync/Merge/MergeStrategies.cs
+317
View File
@@ -0,0 +1,317 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Xml.Linq;
namespace EonaCat.Sync.Merge
{
/// <summary>
/// Interface for merge strategies.
/// </summary>
public interface IMergeStrategy
{
/// <summary>
/// Determines if this strategy can handle the file type.
/// </summary>
bool CanHandle(string filePath);
/// <summary>
/// Performs a 3-way merge operation.
/// </summary>
Task<MergeResult> MergeAsync(string baseFile, string sourceFile, string targetFile);
/// <summary>
/// Gets a human-readable name for the strategy.
/// </summary>
string Name { get; }
}
/// <summary>
/// Result of a merge operation.
/// </summary>
public class MergeResult
{
public bool Success { get; set; }
public string MergedContent { get; set; }
public List<MergeConflict> Conflicts { get; set; } = new List<MergeConflict>();
public int ConflictResolutionCount { get; set; }
}
/// <summary>
/// Represents a merge conflict.
/// </summary>
public class MergeConflict
{
public int LineNumber { get; set; }
public string BaseContent { get; set; }
public string SourceContent { get; set; }
public string TargetContent { get; set; }
public string Resolution { get; set; }
}
/// <summary>
/// Text file merge strategy with line-based 3-way merge.
/// </summary>
public class TextFileMergeStrategy : IMergeStrategy
{
public string Name { get { return "Text File Merge (Line-based)"; } }
public bool CanHandle(string filePath)
{
var extension = Path.GetExtension(filePath).ToLower();
return extension == ".txt" || extension == ".cs" || extension == ".java" ||
extension == ".cpp" || extension == ".py" || extension == ".js" ||
extension == ".config" || extension == ".properties";
}
public async Task<MergeResult> MergeAsync(string baseFile, string sourceFile, string targetFile)
{
var result = new MergeResult();
try
{
var baseLines = await ReadLinesAsync(baseFile);
var sourceLines = await ReadLinesAsync(sourceFile);
var targetLines = await ReadLinesAsync(targetFile);
var mergedLines = new List<string>();
int maxLines = Math.Max(Math.Max(baseLines.Count, sourceLines.Count), targetLines.Count);
for (int i = 0; i < maxLines; i++)
{
string baseLine = i < baseLines.Count ? baseLines[i] : string.Empty;
string sourceLine = i < sourceLines.Count ? sourceLines[i] : string.Empty;
string targetLine = i < targetLines.Count ? targetLines[i] : string.Empty;
if (baseLine == sourceLine && baseLine == targetLine)
{
mergedLines.Add(baseLine);
}
else if (baseLine == targetLine && sourceLine != baseLine)
{
mergedLines.Add(sourceLine);
}
else if (baseLine == sourceLine && targetLine != baseLine)
{
mergedLines.Add(targetLine);
}
else if (sourceLine == targetLine)
{
mergedLines.Add(sourceLine);
}
else
{
// Conflict
var resolution = sourceLine.Length >= targetLine.Length ? sourceLine : targetLine;
result.Conflicts.Add(new MergeConflict
{
LineNumber = i + 1,
BaseContent = baseLine,
SourceContent = sourceLine,
TargetContent = targetLine,
Resolution = resolution
});
mergedLines.Add(resolution);
result.ConflictResolutionCount++;
}
}
result.MergedContent = string.Join(Environment.NewLine, mergedLines);
result.Success = true;
}
catch (Exception ex)
{
result.Success = false;
result.MergedContent = $"Merge failed: {ex.Message}";
}
return result;
}
private async Task<List<string>> ReadLinesAsync(string filePath)
{
var lines = new List<string>();
if (!File.Exists(filePath))
return lines;
return await Task.Run(() =>
{
using (var reader = new StreamReader(filePath))
{
string line;
while ((line = reader.ReadLine()) != null)
{
lines.Add(line);
}
}
return lines;
});
}
}
/// <summary>
/// XML file merge strategy.
/// </summary>
public class XmlFileMergeStrategy : IMergeStrategy
{
public string Name { get { return "XML File Merge"; } }
public bool CanHandle(string filePath)
{
var ext = Path.GetExtension(filePath).ToLower();
return ext == ".xml" || ext == ".config";
}
public async Task<MergeResult> MergeAsync(string baseFile, string sourceFile, string targetFile)
{
var result = new MergeResult();
try
{
var sourceXml = await ReadXmlAsync(sourceFile);
var targetXml = await ReadXmlAsync(targetFile);
var mergedXml = MergeXmlElements(sourceXml, targetXml);
result.MergedContent = mergedXml.ToString();
result.Success = true;
}
catch (Exception ex)
{
result.Success = false;
result.MergedContent = $"XML merge failed: {ex.Message}";
}
return result;
}
private async Task<XElement> ReadXmlAsync(string filePath)
{
if (!File.Exists(filePath))
return new XElement("root");
return await Task.Run(() =>
{
var content = File.ReadAllText(filePath);
return XElement.Parse(content);
});
}
private XElement MergeXmlElements(XElement sourceElem, XElement targetElem)
{
var result = new XElement(sourceElem.Name);
// Merge attributes
foreach (var attr in sourceElem.Attributes())
{
result.SetAttributeValue(attr.Name, attr.Value);
}
foreach (var attr in targetElem.Attributes())
{
if (result.Attributes().FirstOrDefault(a => a.Name == attr.Name) == null)
{
result.SetAttributeValue(attr.Name, attr.Value);
}
}
// Merge elements
foreach (var elem in sourceElem.Elements())
{
result.Add(elem);
}
return result;
}
}
/// <summary>
/// Binary file merge strategy (simple).
/// </summary>
public class BinaryFileMergeStrategy : IMergeStrategy
{
public string Name { get { return "Binary File Merge"; } }
public bool CanHandle(string filePath)
{
return true; // Fallback for unknown types
}
public async Task<MergeResult> MergeAsync(string baseFile, string sourceFile, string targetFile)
{
var result = new MergeResult();
try
{
var sourceBytes = await ReadBytesAsync(sourceFile);
var targetBytes = await ReadBytesAsync(targetFile);
if (sourceBytes.SequenceEqual(targetBytes))
{
result.Success = true;
}
else
{
// Use larger file as resolution
result.MergedContent = "Binary conflict resolved using source file";
result.ConflictResolutionCount = 1;
result.Success = true;
}
}
catch (Exception ex)
{
result.Success = false;
result.MergedContent = $"Binary merge failed: {ex.Message}";
}
return result;
}
private async Task<byte[]> ReadBytesAsync(string filePath)
{
if (!File.Exists(filePath))
return new byte[0];
return await Task.Run(() => File.ReadAllBytes(filePath));
}
}
/// <summary>
/// Merge service that selects appropriate strategy for file type.
/// </summary>
public class MergeService
{
private readonly List<IMergeStrategy> _strategies;
public MergeService()
{
_strategies = new List<IMergeStrategy>
{
new XmlFileMergeStrategy(),
new TextFileMergeStrategy(),
new BinaryFileMergeStrategy()
};
}
/// <summary>
/// Merges three files using the appropriate strategy.
/// </summary>
public async Task<MergeResult> MergeFilesAsync(string baseFile, string sourceFile, string targetFile)
{
var strategy = _strategies.FirstOrDefault(s => s.CanHandle(sourceFile)) ??
_strategies.Last();
return await strategy.MergeAsync(baseFile, sourceFile, targetFile);
}
/// <summary>
/// Registers a custom merge strategy.
/// </summary>
public void RegisterStrategy(IMergeStrategy strategy)
{
_strategies.Insert(0, strategy);
}
}
}
EonaCat.Sync/Models/SyncModels.cs
+117
View File
@@ -0,0 +1,117 @@
using System;
using System.Collections.Generic;
namespace EonaCat.Sync.Models
{
/// <summary>
/// Represents a change or modification detected in the sync source.
/// </summary>
public class SyncChange
{
public string ChangeId { get; set; }
public ChangeType Type { get; set; }
public DateTime DetectedAt { get; set; }
public string SourceId { get; set; }
public Dictionary<string, object> Data { get; set; }
public string EntityType { get; set; }
}
/// <summary>
/// Types of changes that can be detected during synchronization.
/// </summary>
public enum ChangeType
{
Created,
Modified,
Deleted,
Moved,
Renamed
}
/// <summary>
/// Result of a synchronization operation.
/// </summary>
public class SyncResult
{
public bool Success { get; set; }
public int ChangesApplied { get; set; }
public int ConflictsEncountered { get; set; }
public List<string> Errors { get; set; }
public DateTime SyncedAt { get; set; }
public SyncResult()
{
Errors = new List<string>();
SyncedAt = DateTime.UtcNow;
}
}
/// <summary>
/// File metadata for synchronization purposes.
/// </summary>
public class FileMetadata
{
public string FilePath { get; set; }
public long FileSize { get; set; }
public string FileHash { get; set; }
public DateTime LastModified { get; set; }
public string RelativePath { get; set; }
}
/// <summary>
/// Database entity change information.
/// </summary>
public class EntityChange
{
public string EntityName { get; set; }
public object EntityKey { get; set; }
public EntityChangeType ChangeType { get; set; }
public Dictionary<string, object> OldValues { get; set; }
public Dictionary<string, object> NewValues { get; set; }
public DateTime ChangedAt { get; set; }
}
/// <summary>
/// Types of changes for database entities.
/// </summary>
public enum EntityChangeType
{
Added,
Modified,
Deleted
}
/// <summary>
/// Sync session tracking information.
/// </summary>
public class SyncSession
{
public string SessionId { get; set; }
public DateTime StartedAt { get; set; }
public DateTime? CompletedAt { get; set; }
public string SourceIdentifier { get; set; }
public string TargetIdentifier { get; set; }
public List<SyncChange> Changes { get; set; }
public SyncSession()
{
SessionId = Guid.NewGuid().ToString();
StartedAt = DateTime.UtcNow;
Changes = new List<SyncChange>();
}
}
/// <summary>
/// Conflict information when sync conflicts are detected.
/// </summary>
public class SyncConflict
{
public string ConflictId { get; set; }
public string EntityIdentifier { get; set; }
public object SourceValue { get; set; }
public object TargetValue { get; set; }
public DateTime SourceLastModified { get; set; }
public DateTime TargetLastModified { get; set; }
public string ResolutionStrategy { get; set; }
}
}
EonaCat.Sync/Monitoring/MonitoringService.cs
+309
View File
@@ -0,0 +1,309 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
namespace EonaCat.Sync.Monitoring
{
/// <summary>
/// Performance metrics for sync operations.
/// </summary>
public class SyncMetrics
{
public string OperationId { get; set; }
public string OperationType { get; set; } // FileSy nc, DatabaseSync, etc.
public DateTime StartTime { get; set; }
public DateTime? EndTime { get; set; }
public long ElapsedMilliseconds { get; set; }
public int FilesProcessed { get; set; }
public int EntitiesProcessed { get; set; }
public long DataTransferred { get; set; }
public long DataCompressed { get; set; }
public int ErrorCount { get; set; }
public int ConflictCount { get; set; }
public Dictionary<string, object> CustomMetrics { get; set; } = new Dictionary<string, object>();
}
/// <summary>
/// Sync operation counter and analyzer.
/// </summary>
public class SyncMetricsCollector
{
private readonly List<SyncMetrics> _metrics = new List<SyncMetrics>();
private readonly object _lockObject = new object();
public void RecordMetric(SyncMetrics metric)
{
lock (_lockObject)
{
_metrics.Add(metric);
}
}
public SyncMetrics StartOperation(string operationType)
{
var metric = new SyncMetrics
{
OperationId = Guid.NewGuid().ToString(),
OperationType = operationType,
StartTime = DateTime.UtcNow
};
return metric;
}
public void EndOperation(SyncMetrics metric)
{
metric.EndTime = DateTime.UtcNow;
metric.ElapsedMilliseconds = (long)(metric.EndTime.Value - metric.StartTime).TotalMilliseconds;
RecordMetric(metric);
}
public SyncMetricsAggregate GetAggregateMetrics(string operationType = null, int lastDays = 7)
{
lock (_lockObject)
{
var cutoffDate = DateTime.UtcNow.AddDays(-lastDays);
var filtered = _metrics
.Where(m => m.EndTime >= cutoffDate &&
(operationType == null || m.OperationType == operationType))
.ToList();
return new SyncMetricsAggregate
{
TotalOperations = filtered.Count,
SuccessfulOperations = filtered.Count(m => m.ErrorCount == 0),
FailedOperations = filtered.Count(m => m.ErrorCount > 0),
AverageDurationMs = filtered.Any() ? (long)filtered.Average(m => m.ElapsedMilliseconds) : 0,
TotalDataTransferred = filtered.Sum(m => m.DataTransferred),
TotalDataCompressed = filtered.Sum(m => m.DataCompressed),
PeakThroughputMBps = CalculatePeakThroughput(filtered),
TotalConflicts = filtered.Sum(m => m.ConflictCount),
OperationsByType = filtered.GroupBy(m => m.OperationType)
.ToDictionary(g => g.Key, g => g.Count())
};
}
}
public List<SyncMetrics> GetRecentMetrics(int count = 100)
{
lock (_lockObject)
{
return _metrics.OrderByDescending(m => m.StartTime).Take(count).ToList();
}
}
private double CalculatePeakThroughput(List<SyncMetrics> metrics)
{
if (!metrics.Any() || metrics.All(m => m.ElapsedMilliseconds == 0))
return 0;
return metrics.Max(m => m.DataTransferred / (m.ElapsedMilliseconds / 1000.0 / 1024 / 1024));
}
}
/// <summary>
/// Aggregated metrics view.
/// </summary>
public class SyncMetricsAggregate
{
public int TotalOperations { get; set; }
public int SuccessfulOperations { get; set; }
public int FailedOperations { get; set; }
public long AverageDurationMs { get; set; }
public long TotalDataTransferred { get; set; }
public long TotalDataCompressed { get; set; }
public double PeakThroughputMBps { get; set; }
public int TotalConflicts { get; set; }
public Dictionary<string, int> OperationsByType { get; set; }
public double SuccessRate => TotalOperations > 0 ? (double)SuccessfulOperations / TotalOperations * 100 : 100;
public double CompressionRatio => TotalDataTransferred > 0 ? (double)TotalDataCompressed / TotalDataTransferred * 100 : 0;
}
/// <summary>
/// Structured logging interface.
/// </summary>
public interface IStructuredLogger
{
void LogInformation(string message, Dictionary<string, object> context = null);
void LogWarning(string message, Dictionary<string, object> context = null);
void LogError(string message, Exception ex = null, Dictionary<string, object> context = null);
void LogDebug(string message, Dictionary<string, object> context = null);
void LogPerformance(string operationName, long durationMs, Dictionary<string, object> context = null);
}
/// <summary>
/// Console-based structured logger for development.
/// </summary>
public class ConsoleStructuredLogger : IStructuredLogger
{
public void LogInformation(string message, Dictionary<string, object> context = null)
{
LogMessage("INFO", message, context);
}
public void LogWarning(string message, Dictionary<string, object> context = null)
{
LogMessage("WARN", message, context);
}
public void LogError(string message, Exception ex = null, Dictionary<string, object> context = null)
{
LogMessage("ERROR", message, context);
if (ex != null)
{
Console.WriteLine($" Exception: {ex.GetType().Name}: {ex.Message}");
Console.WriteLine($" StackTrace: {ex.StackTrace}");
}
}
public void LogDebug(string message, Dictionary<string, object> context = null)
{
LogMessage("DEBUG", message, context);
}
public void LogPerformance(string operationName, long durationMs, Dictionary<string, object> context = null)
{
var ctxCopy = context ?? new Dictionary<string, object>();
ctxCopy["durationMs"] = durationMs;
LogMessage("PERF", $"Operation '{operationName}' took {durationMs}ms", ctxCopy);
}
private void LogMessage(string level, string message, Dictionary<string, object> context)
{
var timestamp = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff");
var contextStr = context != null && context.Count > 0
? " | " + string.Join(", ", context.Select(kvp => $"{kvp.Key}={kvp.Value}"))
: "";
Console.WriteLine($"[{timestamp}] [{level}] {message}{contextStr}");
}
}
/// <summary>
/// Health monitoring service.
/// </summary>
public class HealthMonitor
{
private readonly Dictionary<string, HealthCheckResult> _checks = new Dictionary<string, HealthCheckResult>();
public void RegisterCheck(string name, Func<Task<bool>> checkAction)
{
_checks[name] = new HealthCheckResult { Name = name, CheckAction = checkAction };
}
public async Task<SystemHealth> CheckHealthAsync()
{
var health = new SystemHealth
{
CheckTime = DateTime.UtcNow,
Checks = new Dictionary<string, bool>()
};
foreach (var kvp in _checks)
{
try
{
health.Checks[kvp.Key] = await kvp.Value.CheckAction();
}
catch
{
health.Checks[kvp.Key] = false;
}
}
health.IsHealthy = health.Checks.All(c => c.Value);
health.Timestamp = DateTime.UtcNow;
return health;
}
}
/// <summary>
/// System health status.
/// </summary>
public class SystemHealth
{
public bool IsHealthy { get; set; }
public DateTime CheckTime { get; set; }
public DateTime Timestamp { get; set; }
public Dictionary<string, bool> Checks { get; set; } = new Dictionary<string, bool>();
}
/// <summary>
/// Individual health check result.
/// </summary>
public class HealthCheckResult
{
public string Name { get; set; }
public Func<Task<bool>> CheckAction { get; set; }
}
/// <summary>
/// Performance profiler for sync operations.
/// </summary>
public class SyncPerformanceProfiler
{
private readonly Stopwatch _stopwatch = new Stopwatch();
private readonly Dictionary<string, Stopwatch> _sections = new Dictionary<string, Stopwatch>();
public void Start()
{
_stopwatch.Restart();
}
public void StartSection(string sectionName)
{
if (!_sections.ContainsKey(sectionName))
_sections[sectionName] = new Stopwatch();
_sections[sectionName].Restart();
}
public void EndSection(string sectionName)
{
if (_sections.TryGetValue(sectionName, out var sw))
{
sw.Stop();
}
}
public long Stop()
{
_stopwatch.Stop();
return _stopwatch.ElapsedMilliseconds;
}
public PerformanceReport GetReport()
{
return new PerformanceReport
{
TotalElapsedMs = _stopwatch.ElapsedMilliseconds,
SectionTimings = _sections.ToDictionary(
kvp => kvp.Key,
kvp => kvp.Value.ElapsedMilliseconds)
};
}
}
/// <summary>
/// Performance profiling report.
/// </summary>
public class PerformanceReport
{
public long TotalElapsedMs { get; set; }
public Dictionary<string, long> SectionTimings { get; set; } = new Dictionary<string, long>();
public override string ToString()
{
var lines = new List<string> { $"Total: {TotalElapsedMs}ms" };
foreach (var section in SectionTimings)
{
lines.Add(string.Format(" {0}: {1}ms", section.Key, section.Value));
}
return string.Join(Environment.NewLine, lines);
}
}
}
EonaCat.Sync/Services/DatabaseSynchronizer.cs
+462
View File
@@ -0,0 +1,462 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using EonaCat.Sync.Interfaces;
using EonaCat.Sync.Models;
namespace EonaCat.Sync.Services
{
/// <summary>
/// Provides database synchronization capabilities for Entity Framework contexts.
/// Supports detecting and applying entity changes across databases.
/// </summary>
public class DatabaseSynchronizer : IDatabaseSynchronizer
{
private readonly DatabaseSyncOptions _options;
public DatabaseSynchronizer(DatabaseSyncOptions options = null)
{
_options = options ?? new DatabaseSyncOptions();
}
/// <summary>
/// Synchronizes database changes from source to target.
/// </summary>
public async Task<SyncResult> SyncDatabaseAsync(string sourceConnectionString, string targetConnectionString, string[] entityNames)
{
var result = new SyncResult();
try
{
// Validate connection strings
ValidateConnectionStrings(sourceConnectionString, targetConnectionString);
if (_options.ClearTargetBeforeSync && entityNames != null && entityNames.Length > 0)
{
await ClearTargetEntitiesAsync(targetConnectionString, entityNames);
}
// Detect changes from source
var changes = await DetectEntityChangesAsync(sourceConnectionString, DateTime.MinValue);
result.ChangesApplied = changes.Count;
// Apply changes to target in batches
if (changes.Count > 0)
{
var batches = changes
.GroupBy(c => c.EntityName)
.ToList();
foreach (var batch in batches)
{
try
{
var changeList = batch.ToList();
await ApplyEntityChangesInBatchesAsync(targetConnectionString, changeList);
}
catch (Exception ex)
{
result.Errors.Add($"Failed to sync entity {batch.Key}: {ex.Message}");
result.ConflictsEncountered++;
}
}
}
// Rebuild indexes if configured
if (_options.RebuildIndexesAfterSync)
{
await RebuildIndexesAsync(targetConnectionString);
}
result.Success = result.Errors.Count == 0;
}
catch (Exception ex)
{
result.Success = false;
result.Errors.Add($"Database sync operation failed: {ex.Message}");
}
return result;
}
/// <summary>
/// Detects entity changes in the database.
/// </summary>
public async Task<List<EntityChange>> DetectEntityChangesAsync(string connectionString, DateTime sinceTime)
{
var changes = new List<EntityChange>();
try
{
// This is a generic implementation that works with change timestamp tracking
// For Entity Framework with better change tracking, use the async DetectChanges methods
using (var connection = CreateConnection(connectionString))
{
await connection.OpenAsync();
// Query for entities with modification tracking
var command = connection.CreateCommand();
command.CommandText = @"
SELECT TABLE_NAME
FROM INFORMATION_SCHEMA.TABLES
WHERE TABLE_TYPE = 'BASE TABLE'";
using (var reader = await command.ExecuteReaderAsync())
{
while (await reader.ReadAsync())
{
var tableName = reader[0].ToString();
// Create a basic change entry for tracking
// In a real scenario, this would query actual change tracking tables
var change = new EntityChange
{
EntityName = tableName,
ChangeType = EntityChangeType.Modified,
ChangedAt = DateTime.UtcNow
};
changes.Add(change);
}
}
}
}
catch (Exception ex)
{
throw new InvalidOperationException($"Failed to detect entity changes: {ex.Message}", ex);
}
return changes;
}
/// <summary>
/// Applies entity changes to target database.
/// </summary>
public async Task<bool> ApplyEntityChangesAsync(string connectionString, List<EntityChange> changes)
{
if (changes == null || changes.Count == 0)
return true;
try
{
using (var connection = CreateConnection(connectionString))
{
await connection.OpenAsync();
foreach (var change in changes)
{
try
{
await ApplySingleChangeAsync(connection, change);
}
catch (Exception ex)
{
if (!_options.UseTransactions)
throw;
// Continue with next change if transactions are disabled
}
}
}
return true;
}
catch (Exception ex)
{
throw new InvalidOperationException($"Failed to apply entity changes: {ex.Message}", ex);
}
}
/// <summary>
/// Gets entity data for synchronization.
/// </summary>
public async Task<List<Dictionary<string, object>>> GetEntityDataAsync(string connectionString, string entityName)
{
var data = new List<Dictionary<string, object>>();
try
{
using (var connection = CreateConnection(connectionString))
{
await connection.OpenAsync();
var command = connection.CreateCommand();
command.CommandText = $"SELECT * FROM [{entityName}]";
command.CommandTimeout = _options.TimeoutSeconds;
using (var reader = await command.ExecuteReaderAsync())
{
var fieldCount = reader.FieldCount;
var fieldNames = Enumerable.Range(0, fieldCount)
.Select(i => reader.GetName(i))
.ToList();
while (await reader.ReadAsync())
{
var record = new Dictionary<string, object>();
for (int i = 0; i < fieldCount; i++)
{
record[fieldNames[i]] = reader.IsDBNull(i) ? null : reader.GetValue(i);
}
data.Add(record);
}
}
}
}
catch (Exception ex)
{
throw new InvalidOperationException($"Failed to get entity data for {entityName}: {ex.Message}", ex);
}
return data;
}
/// <summary>
/// Sets up change tracking for entities.
/// </summary>
public async Task SetupChangeTrackingAsync(string connectionString, string[] entityNames)
{
try
{
using (var connection = CreateConnection(connectionString))
{
await connection.OpenAsync();
foreach (var entityName in entityNames ?? Array.Empty<string>())
{
var command = connection.CreateCommand();
// Attempt to enable SQL Server change tracking if available
try
{
command.CommandText = $@"
ALTER TABLE [{entityName}]
ENABLE CHANGE_TRACKING
WITH (TRACK_COLUMNS_UPDATED = ON)";
await command.ExecuteNonQueryAsync();
}
catch
{
// Change tracking may not be available on this database type
// Continue with other methods
}
}
}
}
catch (Exception ex)
{
throw new InvalidOperationException($"Failed to setup change tracking: {ex.Message}", ex);
}
}
// Private helper methods
private void ValidateConnectionStrings(string sourceConnectionString, string targetConnectionString)
{
if (string.IsNullOrWhiteSpace(sourceConnectionString))
throw new ArgumentException("Source connection string cannot be null or empty", nameof(sourceConnectionString));
if (string.IsNullOrWhiteSpace(targetConnectionString))
throw new ArgumentException("Target connection string cannot be null or empty", nameof(targetConnectionString));
}
private DbConnection CreateConnection(string connectionString)
{
// Auto-detect connection type based on connection string
// For .NET Standard 2.0 compatibility, we'll support basic connection strings
if (connectionString.Contains("Server=") || connectionString.Contains("Data Source="))
{
try
{
// Try to load SQL Server provider
var type = System.Type.GetType("System.Data.SqlClient.SqlConnection, System.Data.SqlClient");
if (type != null)
{
return (DbConnection)Activator.CreateInstance(type, connectionString);
}
}
catch
{
// SQL Client not available
}
}
// Fallback to generic DbConnection - requires provider configuration
throw new NotSupportedException(
"No suitable database connection provider found. Please ensure appropriate NuGet packages are installed " +
"(e.g., System.Data.SqlClient or System.Data.SQLite).");
}
private async Task ApplySingleChangeAsync(DbConnection connection, EntityChange change)
{
var command = connection.CreateCommand();
switch (change.ChangeType)
{
case EntityChangeType.Added:
BuildInsertCommand(command, change);
break;
case EntityChangeType.Modified:
BuildUpdateCommand(command, change);
break;
case EntityChangeType.Deleted:
BuildDeleteCommand(command, change);
break;
}
command.CommandTimeout = _options.TimeoutSeconds;
await command.ExecuteNonQueryAsync();
}
private void BuildInsertCommand(DbCommand command, EntityChange change)
{
if (change.NewValues == null || change.NewValues.Count == 0)
return;
var columns = string.Join(", ", change.NewValues.Keys.Select(k => $"[{k}]"));
var values = string.Join(", ", change.NewValues.Keys.Select(k => $"@{k}"));
command.CommandText = $"INSERT INTO [{change.EntityName}] ({columns}) VALUES ({values})";
foreach (var kvp in change.NewValues)
{
var parameter = command.CreateParameter();
parameter.ParameterName = "@" + kvp.Key;
parameter.Value = kvp.Value ?? DBNull.Value;
command.Parameters.Add(parameter);
}
}
private void BuildUpdateCommand(DbCommand command, EntityChange change)
{
if (change.NewValues == null || change.NewValues.Count == 0)
return;
var setClause = string.Join(", ", change.NewValues.Keys.Select(k => $"[{k}] = @{k}"));
var whereClause = change.EntityKey != null ? "WHERE [Id] = @Id" : "";
command.CommandText = $"UPDATE [{change.EntityName}] SET {setClause} {whereClause}";
foreach (var kvp in change.NewValues)
{
var parameter = command.CreateParameter();
parameter.ParameterName = "@" + kvp.Key;
parameter.Value = kvp.Value ?? DBNull.Value;
command.Parameters.Add(parameter);
}
if (change.EntityKey != null)
{
var keyParam = command.CreateParameter();
keyParam.ParameterName = "@Id";
keyParam.Value = change.EntityKey;
command.Parameters.Add(keyParam);
}
}
private void BuildDeleteCommand(DbCommand command, EntityChange change)
{
if (change.EntityKey == null)
throw new InvalidOperationException("Entity key is required for delete operations");
command.CommandText = $"DELETE FROM [{change.EntityName}] WHERE [Id] = @Id";
var parameter = command.CreateParameter();
parameter.ParameterName = "@Id";
parameter.Value = change.EntityKey;
command.Parameters.Add(parameter);
}
private async Task ApplyEntityChangesInBatchesAsync(string connectionString, List<EntityChange> changes)
{
for (int i = 0; i < changes.Count; i += _options.DatabaseBatchSize)
{
var batch = changes.Skip(i).Take(_options.DatabaseBatchSize).ToList();
if (_options.UseTransactions)
{
using (var connection = CreateConnection(connectionString))
{
await connection.OpenAsync();
using (var transaction = connection.BeginTransaction())
{
try
{
foreach (var change in batch)
{
await ApplySingleChangeAsync(connection, change);
}
transaction.Commit();
}
catch
{
transaction.Rollback();
throw;
}
}
}
}
else
{
await ApplyEntityChangesAsync(connectionString, batch);
}
}
}
private async Task ClearTargetEntitiesAsync(string connectionString, string[] entityNames)
{
using (var connection = CreateConnection(connectionString))
{
await connection.OpenAsync();
if (_options.BypassForeignKeyConstraints)
{
await ExecuteCommandAsync(connection, "EXEC sp_MSForEachTable 'ALTER TABLE ? NOCHECK CONSTRAINT ALL'");
}
foreach (var entityName in entityNames)
{
try
{
await ExecuteCommandAsync(connection, $"DELETE FROM [{entityName}]");
}
catch
{
// Continue with next entity if delete fails
}
}
if (_options.BypassForeignKeyConstraints)
{
await ExecuteCommandAsync(connection, "EXEC sp_MSForEachTable 'ALTER TABLE ? WITH CHECK CHECK CONSTRAINT ALL'");
}
}
}
private async Task RebuildIndexesAsync(string connectionString)
{
using (var connection = CreateConnection(connectionString))
{
await connection.OpenAsync();
await ExecuteCommandAsync(connection, @"
EXEC sp_MSForEachTable 'SET QUOTED_IDENTIFIER ON;
ALTER INDEX ALL ON ? REBUILD'");
}
}
private async Task ExecuteCommandAsync(DbConnection connection, string commandText)
{
using (var command = connection.CreateCommand())
{
command.CommandText = commandText;
command.CommandTimeout = _options.TimeoutSeconds;
await command.ExecuteNonQueryAsync();
}
}
}
}
EonaCat.Sync/Services/FileSynchronizer.cs
+357
View File
@@ -0,0 +1,357 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Threading.Tasks;
using EonaCat.Sync.Interfaces;
using EonaCat.Sync.Models;
namespace EonaCat.Sync.Services
{
/// <summary>
/// Provides file synchronization capabilities with change detection.
/// </summary>
public class FileSynchronizer : IFileSynchronizer
{
private readonly FileSyncOptions _options;
public FileSynchronizer(FileSyncOptions options = null)
{
_options = options ?? new FileSyncOptions();
}
/// <summary>
/// Synchronizes files from source to target directory.
/// </summary>
public async Task<SyncResult> SyncFilesAsync(string sourceDirectory, string targetDirectory)
{
var result = new SyncResult();
try
{
ValidateDirectories(sourceDirectory, targetDirectory);
// Detect changes in source
var changes = await DetectFileChangesAsync(sourceDirectory, DateTime.MinValue);
result.ChangesApplied = changes.Count;
// Apply changes to target
foreach (var change in changes)
{
try
{
await ApplyFileChangeAsync(sourceDirectory, targetDirectory, change);
}
catch (Exception ex)
{
result.Errors.Add($"Failed to apply change {change.ChangeId}: {ex.Message}");
result.ConflictsEncountered++;
}
}
// Handle deletions if configured
if (_options.DeleteMissingFilesInTarget)
{
await RemoveDeletedFilesAsync(sourceDirectory, targetDirectory);
}
result.Success = result.Errors.Count == 0;
}
catch (Exception ex)
{
result.Success = false;
result.Errors.Add($"Sync operation failed: {ex.Message}");
}
return result;
}
/// <summary>
/// Detects changes in a directory since last sync.
/// </summary>
public async Task<List<SyncChange>> DetectFileChangesAsync(string directory, DateTime sinceTime)
{
var changes = new List<SyncChange>();
try
{
if (!Directory.Exists(directory))
return changes;
var dirInfo = new DirectoryInfo(directory);
var files = GetFilesRecursive(dirInfo);
foreach (var file in files)
{
// Check file patterns to exclude
if (ShouldExcludeFile(file.Name))
continue;
if (file.LastWriteTimeUtc > sinceTime)
{
var change = new SyncChange
{
ChangeId = Guid.NewGuid().ToString(),
Type = ChangeType.Modified,
DetectedAt = DateTime.UtcNow,
SourceId = file.FullName,
EntityType = "File",
Data = new Dictionary<string, object>
{
{ "FilePath", file.FullName },
{ "FileSize", file.Length },
{ "LastModified", file.LastWriteTimeUtc },
{ "RelativePath", GetRelativePath(directory, file.FullName) }
}
};
if (_options.VerifyFileIntegrity)
{
change.Data["FileHash"] = await ComputeFileHashAsync(file.FullName);
}
changes.Add(change);
}
}
}
catch (Exception ex)
{
throw new InvalidOperationException($"Failed to detect file changes in {directory}: {ex.Message}", ex);
}
return changes;
}
/// <summary>
/// Copies a file from source to target with verification.
/// </summary>
public async Task<bool> CopyFileAsync(string sourcePath, string targetPath)
{
try
{
if (!File.Exists(sourcePath))
throw new FileNotFoundException($"Source file not found: {sourcePath}");
// Create target directory if needed
var targetDir = Path.GetDirectoryName(targetPath);
if (!Directory.Exists(targetDir))
{
Directory.CreateDirectory(targetDir);
}
// Copy with retry logic
int retries = 0;
while (retries < _options.MaxRetries)
{
try
{
if (_options.ChunkSize > 0 && new FileInfo(sourcePath).Length > _options.ChunkSize)
{
await CopyFileInChunksAsync(sourcePath, targetPath);
}
else
{
using (var sourceStream = File.OpenRead(sourcePath))
using (var targetStream = File.Create(targetPath))
{
await sourceStream.CopyToAsync(targetStream, _options.BufferSizeBytes);
}
}
// Verify integrity if configured
if (_options.VerifyFileIntegrity)
{
var sourceHash = await ComputeFileHashAsync(sourcePath);
var targetHash = await ComputeFileHashAsync(targetPath);
if (sourceHash != targetHash)
{
throw new InvalidOperationException("File hash mismatch after copy");
}
}
// Preserve timestamps if configured
if (_options.PreserveTimestamps)
{
var fileInfo = new FileInfo(sourcePath);
File.SetLastWriteTimeUtc(targetPath, fileInfo.LastWriteTimeUtc);
}
return true;
}
catch (Exception ex) when (retries < _options.MaxRetries - 1)
{
retries++;
await Task.Delay(1000 * retries); // Exponential backoff
}
}
return false;
}
catch (Exception ex)
{
throw new InvalidOperationException($"Failed to copy file from {sourcePath} to {targetPath}: {ex.Message}", ex);
}
}
/// <summary>
/// Gets file metadata for comparison.
/// </summary>
public async Task<FileMetadata> GetFileMetadataAsync(string filePath)
{
try
{
if (!File.Exists(filePath))
throw new FileNotFoundException($"File not found: {filePath}");
var fileInfo = new FileInfo(filePath);
var hash = _options.VerifyFileIntegrity ? await ComputeFileHashAsync(filePath) : string.Empty;
return new FileMetadata
{
FilePath = filePath,
FileSize = fileInfo.Length,
FileHash = hash,
LastModified = fileInfo.LastWriteTimeUtc,
RelativePath = filePath
};
}
catch (Exception ex)
{
throw new InvalidOperationException($"Failed to get metadata for {filePath}: {ex.Message}", ex);
}
}
/// <summary>
/// Computes hash for file integrity verification.
/// </summary>
public async Task<string> ComputeFileHashAsync(string filePath)
{
try
{
using (var sha256 = SHA256.Create())
using (var stream = File.OpenRead(filePath))
{
var hashBytes = await Task.Run(() => sha256.ComputeHash(stream));
return Convert.ToBase64String(hashBytes);
}
}
catch (Exception ex)
{
throw new InvalidOperationException($"Failed to compute hash for {filePath}: {ex.Message}", ex);
}
}
// Private helper methods
private void ValidateDirectories(string sourceDirectory, string targetDirectory)
{
if (!Directory.Exists(sourceDirectory))
throw new DirectoryNotFoundException($"Source directory not found: {sourceDirectory}");
if (!Directory.Exists(targetDirectory))
{
Directory.CreateDirectory(targetDirectory);
}
}
private List<FileInfo> GetFilesRecursive(DirectoryInfo directory)
{
var files = new List<FileInfo>();
try
{
files.AddRange(directory.GetFiles());
foreach (var subDir in directory.GetDirectories())
{
// Check for symbolic link if not following them
if (!_options.FollowSymbolicLinks && IsSymbolicLink(subDir))
continue;
files.AddRange(GetFilesRecursive(subDir));
}
}
catch (UnauthorizedAccessException)
{
// Skip directories we don't have access to
}
return files;
}
private bool IsSymbolicLink(DirectoryInfo directory)
{
return (directory.Attributes & FileAttributes.ReparsePoint) == FileAttributes.ReparsePoint;
}
private bool ShouldExcludeFile(string fileName)
{
var patterns = _options.ExcludeFilePatterns?.Split(';') ?? Array.Empty<string>();
return patterns.Any(pattern =>
fileName.EndsWith(pattern.Replace("*", ""), StringComparison.OrdinalIgnoreCase));
}
private string GetRelativePath(string basePath, string fullPath)
{
if (fullPath.StartsWith(basePath))
{
return fullPath.Substring(basePath.Length).TrimStart(Path.DirectorySeparatorChar);
}
return fullPath;
}
private async Task ApplyFileChangeAsync(string sourceDirectory, string targetDirectory, SyncChange change)
{
var relativePath = change.Data.ContainsKey("RelativePath")
? (string)change.Data["RelativePath"]
: Path.GetFileName(change.SourceId);
var sourcePath = Path.Combine(sourceDirectory, relativePath);
var targetPath = Path.Combine(targetDirectory, relativePath);
if (File.Exists(sourcePath))
{
await CopyFileAsync(sourcePath, targetPath);
}
}
private async Task RemoveDeletedFilesAsync(string sourceDirectory, string targetDirectory)
{
var targetFiles = GetFilesRecursive(new DirectoryInfo(targetDirectory));
foreach (var targetFile in targetFiles)
{
var relativePath = GetRelativePath(targetDirectory, targetFile.FullName);
var sourcePath = Path.Combine(sourceDirectory, relativePath);
if (!File.Exists(sourcePath))
{
try
{
File.Delete(targetFile.FullName);
}
catch (Exception ex)
{
// Log error but continue with other files
}
}
}
}
private async Task CopyFileInChunksAsync(string sourcePath, string targetPath)
{
using (var sourceStream = File.OpenRead(sourcePath))
using (var targetStream = File.Create(targetPath))
{
byte[] buffer = new byte[_options.ChunkSize];
int bytesRead;
while ((bytesRead = await sourceStream.ReadAsync(buffer, 0, buffer.Length)) > 0)
{
await targetStream.WriteAsync(buffer, 0, bytesRead);
}
}
}
}
}
EonaCat.Sync/Services/SyncService.cs
+348
View File
@@ -0,0 +1,348 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using EonaCat.Sync.Interfaces;
using EonaCat.Sync.Models;
namespace EonaCat.Sync.Services
{
/// <summary>
/// Main synchronization service that orchestrates file and database synchronization.
/// </summary>
public class SyncService : ISyncService
{
private readonly IFileSynchronizer _fileSynchronizer;
private readonly IDatabaseSynchronizer _databaseSynchronizer;
private readonly IConflictResolver _conflictResolver;
private readonly IChangeTracker _changeTracker;
private readonly ISyncNotifier _notifier;
private readonly Dictionary<string, SyncSession> _sessions;
public SyncService(
IFileSynchronizer fileSynchronizer = null,
IDatabaseSynchronizer databaseSynchronizer = null,
IConflictResolver conflictResolver = null,
IChangeTracker changeTracker = null,
ISyncNotifier notifier = null)
{
_fileSynchronizer = fileSynchronizer ?? new FileSynchronizer();
_databaseSynchronizer = databaseSynchronizer ?? new DatabaseSynchronizer();
_conflictResolver = conflictResolver ?? new DefaultConflictResolver();
_changeTracker = changeTracker ?? new InMemoryChangeTracker();
_notifier = notifier;
_sessions = new Dictionary<string, SyncSession>();
}
/// <summary>
/// Starts a synchronization session.
/// </summary>
public async Task<SyncSession> StartSyncSessionAsync(string sourceId, string targetId)
{
var session = new SyncSession
{
SourceIdentifier = sourceId,
TargetIdentifier = targetId
};
_sessions[session.SessionId] = session;
_notifier?.NotifyProgress($"Sync session started: {session.SessionId}", 0);
return await Task.FromResult(session);
}
/// <summary>
/// Synchronizes files between source and target.
/// </summary>
public async Task<SyncResult> SyncFilesAsync(string sourceDirectory, string targetDirectory)
{
try
{
_notifier?.NotifyProgress("Starting file synchronization", 10);
var result = await _fileSynchronizer.SyncFilesAsync(sourceDirectory, targetDirectory);
_notifier?.NotifyProgress("File synchronization completed", 50);
return result;
}
catch (Exception ex)
{
_notifier?.NotifyError($"File sync failed: {ex.Message}");
throw;
}
}
/// <summary>
/// Synchronizes database between source and target.
/// </summary>
public async Task<SyncResult> SyncDatabaseAsync(string sourceConnectionString, string targetConnectionString, string[] entityNames)
{
try
{
_notifier?.NotifyProgress("Starting database synchronization", 30);
var result = await _databaseSynchronizer.SyncDatabaseAsync(sourceConnectionString, targetConnectionString, entityNames);
_notifier?.NotifyProgress("Database synchronization completed", 80);
return result;
}
catch (Exception ex)
{
_notifier?.NotifyError($"Database sync failed: {ex.Message}");
throw;
}
}
/// <summary>
/// Performs bidirectional synchronization.
/// </summary>
public async Task<SyncResult> SyncBidirectionalAsync(string location1, string location2, SyncOptions options)
{
var result = new SyncResult();
options = options ?? new SyncOptions();
try
{
_notifier?.NotifyProgress("Starting bidirectional sync", 5);
// Sync from location1 to location2
var result1to2 = await SyncFilesAsync(location1, location2);
result.ChangesApplied += result1to2.ChangesApplied;
result.Errors.AddRange(result1to2.Errors);
// If bidirectional, also sync from location2 to location1
if (options.BidirectionalSync)
{
_notifier?.NotifyProgress("Syncing in reverse direction", 40);
var result2to1 = await SyncFilesAsync(location2, location1);
result.ChangesApplied += result2to1.ChangesApplied;
result.Errors.AddRange(result2to1.Errors);
}
result.Success = result.Errors.Count == 0;
_notifier?.NotifyCompletion(result);
}
catch (Exception ex)
{
result.Success = false;
result.Errors.Add($"Bidirectional sync failed: {ex.Message}");
_notifier?.NotifyError(ex.Message);
}
return result;
}
/// <summary>
/// Completes a sync session.
/// </summary>
public async Task<bool> CompleteSyncSessionAsync(string sessionId)
{
if (_sessions.TryGetValue(sessionId, out var session))
{
session.CompletedAt = DateTime.UtcNow;
_notifier?.NotifyProgress($"Sync session completed: {sessionId}", 100);
return await Task.FromResult(true);
}
return false;
}
/// <summary>
/// Gets sync session status.
/// </summary>
public async Task<SyncSession> GetSyncSessionAsync(string sessionId)
{
_sessions.TryGetValue(sessionId, out var session);
return await Task.FromResult(session);
}
/// <summary>
/// Performs full synchronization including files and database.
/// </summary>
public async Task<SyncResult> SyncFullAsync(
string sourceFileDir,
string targetFileDir,
string sourceDbConnection,
string targetDbConnection,
string[] entityNames,
SyncOptions options = null)
{
var result = new SyncResult();
options = options ?? new SyncOptions();
try
{
var session = await StartSyncSessionAsync("source", "target");
// Sync files first
_notifier?.NotifyProgress("Syncing files", 20);
var fileResult = await SyncFilesAsync(sourceFileDir, targetFileDir);
result.ChangesApplied += fileResult.ChangesApplied;
result.Errors.AddRange(fileResult.Errors);
// Sync database
_notifier?.NotifyProgress("Syncing database", 60);
var dbResult = await SyncDatabaseAsync(sourceDbConnection, targetDbConnection, entityNames);
result.ChangesApplied += dbResult.ChangesApplied;
result.Errors.AddRange(dbResult.Errors);
// Complete session
await CompleteSyncSessionAsync(session.SessionId);
result.Success = result.Errors.Count == 0;
_notifier?.NotifyCompletion(result);
}
catch (Exception ex)
{
result.Success = false;
result.Errors.Add($"Full sync failed: {ex.Message}");
_notifier?.NotifyError(ex.Message);
}
return result;
}
}
/// <summary>
/// Default implementation of conflict resolver with last-write-wins strategy.
/// </summary>
public class DefaultConflictResolver : IConflictResolver
{
/// <summary>
/// Resolves sync conflicts using configured strategy.
/// </summary>
public async Task<object> ResolveConflictAsync(SyncConflict conflict)
{
var strategy = conflict.ResolutionStrategy ?? "LastWriteWins";
object resolvedValue = conflict.SourceValue;
switch (strategy)
{
case "LastWriteWins":
resolvedValue = conflict.SourceLastModified > conflict.TargetLastModified
? conflict.SourceValue
: conflict.TargetValue;
break;
case "SourceWins":
resolvedValue = conflict.SourceValue;
break;
case "TargetWins":
resolvedValue = conflict.TargetValue;
break;
case "Manual":
// In a real implementation, this would prompt user or trigger callback
resolvedValue = conflict.SourceValue;
break;
case "Merge":
// For mergeable types, attempt merge
resolvedValue = AttemptMerge(conflict.SourceValue, conflict.TargetValue);
break;
}
return await Task.FromResult(resolvedValue);
}
/// <summary>
/// Gets resolution strategy for a conflict type.
/// </summary>
public string GetResolutionStrategy(ChangeType changeType)
{
switch (changeType)
{
case ChangeType.Modified:
return "LastWriteWins";
case ChangeType.Deleted:
return "SourceWins";
case ChangeType.Created:
return "TargetWins";
default:
return "LastWriteWins";
}
}
private object AttemptMerge(object source, object target)
{
// Simple merge for collections
if (source is string s && target is string t)
{
return $"{s}; {t}";
}
return source ?? target;
}
}
/// <summary>
/// In-memory implementation of change tracker.
/// </summary>
public class InMemoryChangeTracker : IChangeTracker
{
private readonly List<SyncChange> _changes = new List<SyncChange>();
/// <summary>
/// Records a change for tracking.
/// </summary>
public async Task RecordChangeAsync(SyncChange change)
{
_changes.Add(change);
await Task.CompletedTask;
}
/// <summary>
/// Gets tracked changes since a specific time.
/// </summary>
public async Task<List<SyncChange>> GetTrackedChangesAsync(DateTime sinceTime)
{
return await Task.FromResult(_changes.Where(c => c.DetectedAt >= sinceTime).ToList());
}
/// <summary>
/// Clears tracked changes.
/// </summary>
public async Task ClearTrackedChangesAsync()
{
_changes.Clear();
await Task.CompletedTask;
}
}
/// <summary>
/// Default no-op implementation of sync notifier.
/// </summary>
public class DefaultSyncNotifier : ISyncNotifier
{
/// <summary>
/// Notifies about sync progress.
/// </summary>
public void NotifyProgress(string message, int percentage)
{
System.Diagnostics.Debug.WriteLine($"[{percentage}%] {message}");
}
/// <summary>
/// Notifies about sync errors.
/// </summary>
public void NotifyError(string errorMessage)
{
System.Diagnostics.Debug.WriteLine($"[ERROR] {errorMessage}");
}
/// <summary>
/// Notifies about sync completion.
/// </summary>
public void NotifyCompletion(SyncResult result)
{
System.Diagnostics.Debug.WriteLine(
$"[COMPLETE] Changes: {result.ChangesApplied}, Conflicts: {result.ConflictsEncountered}, Success: {result.Success}");
}
/// <summary>
/// Notifies about conflict detection.
/// </summary>
public void NotifyConflict(SyncConflict conflict)
{
System.Diagnostics.Debug.WriteLine($"[CONFLICT] {conflict.EntityIdentifier}: {conflict.SourceValue} vs {conflict.TargetValue}");
}
}
}
EonaCat.Sync/SyncOptions.cs
+127
View File
@@ -0,0 +1,127 @@
using System;
namespace EonaCat.Sync
{
/// <summary>
/// Configuration options for synchronization operations.
/// </summary>
public class SyncOptions
{
/// <summary>
/// Conflict resolution strategy: "LastWriteWins", "Manual", "SourceWins", "TargetWins"
/// </summary>
public string ConflictResolutionStrategy { get; set; } = "LastWriteWins";
/// <summary>
/// Whether to delete files in target that don't exist in source.
/// </summary>
public bool DeleteMissingFilesInTarget { get; set; } = false;
/// <summary>
/// Whether to delete entities in target that don't exist in source.
/// </summary>
public bool DeleteMissingEntitiesInTarget { get; set; } = false;
/// <summary>
/// Whether to perform validation after sync.
/// </summary>
public bool ValidateAfterSync { get; set; } = true;
/// <summary>
/// Maximum number of retries for failed operations.
/// </summary>
public int MaxRetries { get; set; } = 3;
/// <summary>
/// Timeout in seconds for operations.
/// </summary>
public int TimeoutSeconds { get; set; } = 300;
/// <summary>
/// Filter for file patterns to exclude (semicolon-separated).
/// </summary>
public string ExcludeFilePatterns { get; set; } = "*.tmp;*.temp;*.bak";
/// <summary>
/// Buffer size in bytes for file operations.
/// </summary>
public int BufferSizeBytes { get; set; } = 65536; // 64KB
/// <summary>
/// Whether to perform bidirectional sync.
/// </summary>
public bool BidirectionalSync { get; set; } = false;
/// <summary>
/// Whether to preserve file timestamps.
/// </summary>
public bool PreserveTimestamps { get; set; } = true;
/// <summary>
/// Database entity batch size for operations.
/// </summary>
public int DatabaseBatchSize { get; set; } = 1000;
/// <summary>
/// Whether to verify file integrity using hashes.
/// </summary>
public bool VerifyFileIntegrity { get; set; } = true;
}
/// <summary>
/// File sync specific options.
/// </summary>
public class FileSyncOptions : SyncOptions
{
/// <summary>
/// Whether to compress files during transfer.
/// </summary>
public bool CompressTransfers { get; set; } = false;
/// <summary>
/// Minimum file size (bytes) before attempting compression.
/// </summary>
public long CompressionThreshold { get; set; } = 1048576; // 1MB
/// <summary>
/// Whether to follow symbolic links.
/// </summary>
public bool FollowSymbolicLinks { get; set; } = false;
/// <summary>
/// Chunk size in bytes for large file transfers.
/// </summary>
public long ChunkSize { get; set; } = 5242880; // 5MB
}
/// <summary>
/// Database sync specific options.
/// </summary>
public class DatabaseSyncOptions : SyncOptions
{
/// <summary>
/// Whether to bypass foreign key constraints during sync.
/// </summary>
public bool BypassForeignKeyConstraints { get; set; } = false;
/// <summary>
/// Whether to use transactions for each batch.
/// </summary>
public bool UseTransactions { get; set; } = true;
/// <summary>
/// Comma-separated list of entity names to sync.
/// </summary>
public string EntitiesToSync { get; set; }
/// <summary>
/// Whether to rebuild indexes after sync.
/// </summary>
public bool RebuildIndexesAfterSync { get; set; } = false;
/// <summary>
/// Whether to clear target data before sync.
/// </summary>
public bool ClearTargetBeforeSync { get; set; } = false;
}
}
EonaCat.Sync/SyncServiceFactory.cs
+186
View File
@@ -0,0 +1,186 @@
using System;
using System.Threading.Tasks;
using EonaCat.Sync.Interfaces;
using EonaCat.Sync.Services;
namespace EonaCat.Sync
{
/// <summary>
/// Main entry point for the EonaCat Synchronization Service.
/// Provides easy access to file and database synchronization capabilities.
/// </summary>
public class SyncServiceFactory
{
/// <summary>
/// Creates a sync service with default implementations.
/// </summary>
public static SyncService CreateSyncService(ISyncNotifier notifier = null)
{
var fileSynchronizer = new FileSynchronizer();
var databaseSynchronizer = new DatabaseSynchronizer();
var conflictResolver = new DefaultConflictResolver();
var changeTracker = new InMemoryChangeTracker();
var syncNotifier = notifier ?? new DefaultSyncNotifier();
return new SyncService(
fileSynchronizer,
databaseSynchronizer,
conflictResolver,
changeTracker,
syncNotifier);
}
/// <summary>
/// Creates a sync service with custom file sync options.
/// </summary>
public static SyncService CreateFileSyncService(FileSyncOptions options = null)
{
var fileSynchronizer = new FileSynchronizer(options);
var databaseSynchronizer = new DatabaseSynchronizer();
var conflictResolver = new DefaultConflictResolver();
var changeTracker = new InMemoryChangeTracker();
var notifier = new DefaultSyncNotifier();
return new SyncService(
fileSynchronizer,
databaseSynchronizer,
conflictResolver,
changeTracker,
notifier);
}
/// <summary>
/// Creates a sync service with custom database sync options.
/// </summary>
public static SyncService CreateDatabaseSyncService(DatabaseSyncOptions options = null)
{
var fileSynchronizer = new FileSynchronizer();
var databaseSynchronizer = new DatabaseSynchronizer(options);
var conflictResolver = new DefaultConflictResolver();
var changeTracker = new InMemoryChangeTracker();
var notifier = new DefaultSyncNotifier();
return new SyncService(
fileSynchronizer,
databaseSynchronizer,
conflictResolver,
changeTracker,
notifier);
}
/// <summary>
/// Creates a fully customized sync service.
/// </summary>
public static SyncService CreateCustomSyncService(
FileSyncOptions fileSyncOptions = null,
DatabaseSyncOptions databaseSyncOptions = null,
ISyncNotifier notifier = null)
{
var fileSynchronizer = new FileSynchronizer(fileSyncOptions);
var databaseSynchronizer = new DatabaseSynchronizer(databaseSyncOptions);
var conflictResolver = new DefaultConflictResolver();
var changeTracker = new InMemoryChangeTracker();
var syncNotifier = notifier ?? new DefaultSyncNotifier();
return new SyncService(
fileSynchronizer,
databaseSynchronizer,
conflictResolver,
changeTracker,
syncNotifier);
}
}
/// <summary>
/// Example usage of the synchronization service.
/// </summary>
public class SyncExample
{
/// <summary>
/// Example: Synchronize files between two directories.
/// </summary>
public static async Task ExampleFileSyncAsync()
{
var syncService = SyncServiceFactory.CreateSyncService();
string sourceDir = @"C:\Source\Files";
string targetDir = @"C:\Target\Files";
var result = await syncService.SyncFilesAsync(sourceDir, targetDir);
Console.WriteLine($"Sync completed. Changes applied: {result.ChangesApplied}");
Console.WriteLine($"Success: {result.Success}");
}
/// <summary>
/// Example: Synchronize database between two servers.
/// </summary>
public static async Task ExampleDatabaseSyncAsync()
{
var options = new DatabaseSyncOptions
{
UseTransactions = true,
DatabaseBatchSize = 500
};
var syncService = SyncServiceFactory.CreateDatabaseSyncService(options);
string sourceConnection = "Server=SourceServer;Database=SourceDB;Integrated Security=true;";
string targetConnection = "Server=TargetServer;Database=TargetDB;Integrated Security=true;";
string[] entityNames = { "Users", "Products", "Orders" };
var result = await syncService.SyncDatabaseAsync(sourceConnection, targetConnection, entityNames);
Console.WriteLine($"Database sync completed. Changes applied: {result.ChangesApplied}");
Console.WriteLine($"Success: {result.Success}");
}
/// <summary>
/// Example: Full synchronization of both files and database.
/// </summary>
public static async Task ExampleFullSyncAsync()
{
var syncService = SyncServiceFactory.CreateSyncService();
var options = new SyncOptions
{
ConflictResolutionStrategy = "LastWriteWins",
DeleteMissingFilesInTarget = false,
ValidateAfterSync = true
};
string sourceFileDir = @"C:\System1\Data";
string targetFileDir = @"C:\System2\Data";
string sourceDb = "Server=System1;Database=AppDB;";
string targetDb = "Server=System2;Database=AppDB;";
string[] entities = { "Users", "Settings", "Documents" };
var result = await syncService.SyncFullAsync(
sourceFileDir, targetFileDir, sourceDb, targetDb, entities, options);
Console.WriteLine($"Full sync result - Changes: {result.ChangesApplied}, " +
$"Conflicts: {result.ConflictsEncountered}, Success: {result.Success}");
}
/// <summary>
/// Example: Bidirectional file synchronization.
/// </summary>
public static async Task ExampleBidirectionalSyncAsync()
{
var syncService = SyncServiceFactory.CreateSyncService();
var options = new SyncOptions
{
BidirectionalSync = true,
ConflictResolutionStrategy = "LastWriteWins"
};
var result = await syncService.SyncBidirectionalAsync(
@"C:\Location1",
@"C:\Location2",
options);
Console.WriteLine($"Bidirectional sync completed. Changes: {result.ChangesApplied}");
}
}
}
EonaCat.Sync/icon.ico
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 248 KiB

EonaCat.Sync/icon.png
BIN
View File
Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 88 KiB

Examples/ConsoleApp/EonaCat.Sync.Example.ConsoleApp.csproj
+16
View File
@@ -0,0 +1,16 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net6.0</TargetFramework>
<LangVersion>latest</LangVersion>
<Nullable>enable</Nullable>
<AssemblyName>EonaCat.Sync.Example.ConsoleApp</AssemblyName>
<RootNamespace>EonaCat.Sync.Examples.ConsoleApp</RootNamespace>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\..\EonaCat.Sync\EonaCat.Sync.csproj" />
</ItemGroup>
</Project>
Examples/ConsoleApp/Program.cs
+199
View File
@@ -0,0 +1,199 @@
// <auto-generated>
// This file is part of EonaCat.Sync examples
// </auto-generated>
using System;
using System.IO;
using System.Threading.Tasks;
using EonaCat.Sync;
namespace EonaCat.Sync.Examples.ConsoleApp
{
/// <summary>
/// Console application example demonstrating basic file synchronization.
/// </summary>
class Program
{
static async Task Main(string[] args)
{
Console.WriteLine("=== EonaCat.Sync Console Example ===\n");
try
{
// Example 1: Basic file sync
await RunBasicFileSync();
// Example 2: File sync with options
await RunFileSyncWithOptions();
// Example 3: Database sync
await RunBasicDatabaseSync();
// Example 4: Bidirectional sync
await RunBidirectionalSync();
Console.WriteLine("\n✓ All examples completed successfully!");
}
catch (Exception ex)
{
Console.Error.WriteLine($"✗ Error: {ex.Message}");
}
}
/// <summary>
/// Example 1: Basic file synchronization
/// </summary>
static async Task RunBasicFileSync()
{
Console.WriteLine("Example 1: Basic File Sync");
Console.WriteLine("---------------------------");
var source = Path.Combine(Path.GetTempPath(), "sync_source");
var target = Path.Combine(Path.GetTempPath(), "sync_target");
try
{
// Create test files
Directory.CreateDirectory(source);
File.WriteAllText(Path.Combine(source, "test1.txt"), "Hello World");
File.WriteAllText(Path.Combine(source, "test2.txt"), "Test Content");
// Create sync service
var syncService = SyncServiceFactory.CreateSyncService();
// Synchronize files
Console.WriteLine($"Syncing from {source}");
Console.WriteLine($"Syncing to {target}");
var result = await syncService.SyncFilesAsync(source, target);
if (result.Success)
{
Console.WriteLine($"✓ Sync successful! ({result.FilesChanged} files changed)\n");
}
else
{
Console.WriteLine($"✗ Sync failed: {result.ErrorMessage}\n");
}
}
catch (Exception ex)
{
Console.WriteLine($"✗ Example failed: {ex.Message}\n");
}
}
/// <summary>
/// Example 2: File sync with custom options
/// </summary>
static async Task RunFileSyncWithOptions()
{
Console.WriteLine("Example 2: File Sync with Options");
Console.WriteLine("----------------------------------");
var source = Path.Combine(Path.GetTempPath(), "sync_source2");
var target = Path.Combine(Path.GetTempPath(), "sync_target2");
try
{
Directory.CreateDirectory(source);
File.WriteAllText(Path.Combine(source, "important.txt"), "Critical Data");
File.WriteAllText(Path.Combine(source, "readme.md"), "Documentation");
var options = new FileSyncOptions
{
ConflictResolutionStrategy = ConflictResolutionStrategy.LastWriteWins,
DeleteMissingInTarget = false,
VerifyFileIntegrity = true,
ExcludePatterns = new[] { "*.tmp", "*.log" },
BufferSize = (int)(1024 * 1024) // 1 MB
};
var syncService = SyncServiceFactory.CreateFileSyncService();
Console.WriteLine($"Syncing with custom options...");
var result = await syncService.SyncFilesAsync(source, target, options);
if (result.Success)
{
Console.WriteLine($"✓ Sync complete! Files: {result.FilesChanged}\n");
}
}
catch (Exception ex)
{
Console.WriteLine($"✗ Example failed: {ex.Message}\n");
}
}
/// <summary>
/// Example 3: Database synchronization
/// </summary>
static async Task RunBasicDatabaseSync()
{
Console.WriteLine("Example 3: Database Sync (Conceptual)");
Console.WriteLine("--------------------------------------");
var sourceConnection = "Server=.;Database=SourceDB;Integrated Security=true;";
var targetConnection = "Server=.;Database=TargetDB;Integrated Security=true;";
var entities = new[] { "Users", "Products", "Orders" };
try
{
var syncService = SyncServiceFactory.CreateDatabaseSyncService();
var options = new DatabaseSyncOptions
{
BatchSize = 1000,
VerifyAfterSync = true,
EnableTransactions = true
};
Console.WriteLine($"Source: {sourceConnection}");
Console.WriteLine($"Target: {targetConnection}");
Console.WriteLine($"Entities: {string.Join(", ", entities)}");
// Note: This example requires actual database setup
Console.WriteLine("(Requires actual database configuration)\n");
}
catch (Exception ex)
{
Console.WriteLine($"Note: {ex.Message}\n");
}
}
/// <summary>
/// Example 4: Bidirectional synchronization
/// </summary>
static async Task RunBidirectionalSync()
{
Console.WriteLine("Example 4: Bidirectional Sync");
Console.WriteLine("------------------------------");
var computer1 = Path.Combine(Path.GetTempPath(), "computer1");
var computer2 = Path.Combine(Path.GetTempPath(), "computer2");
try
{
// Setup directories
Directory.CreateDirectory(computer1);
Directory.CreateDirectory(computer2);
File.WriteAllText(Path.Combine(computer1, "file1.txt"), "From Computer 1");
File.WriteAllText(Path.Combine(computer2, "file2.txt"), "From Computer 2");
var syncService = SyncServiceFactory.CreateSyncService();
Console.WriteLine("Syncing Computer 1 → Computer 2");
await syncService.SyncFilesAsync(computer1, computer2);
Console.WriteLine("Syncing Computer 2 → Computer 1");
var result = await syncService.SyncFilesAsync(computer2, computer1);
if (result.Success)
{
Console.WriteLine($"✓ Bidirectional sync complete!\n");
}
}
catch (Exception ex)
{
Console.WriteLine($"✗ Example failed: {ex.Message}\n");
}
}
}
}
LICENSE
+156 -25
View File
@@ -1,64 +1,195 @@
Apache License Apache License
Version 2.0, January 2004 Version 2.0, January 2004
http://www.apache.org/licenses/ http://www.apache.org/licenses/
https://EonaCat.com/license/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
OF SOFTWARE BY EONACAT (JEROEN SAEY)
1. Definitions. 1. Definitions.
"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. "Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: 4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices stating that You changed the files; and (b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. (d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. 9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work. APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2026 EonaCat Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License"); Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License. you may not use this file except in compliance with the License.
README.md
+552 -2
View File
@@ -1,3 +1,553 @@
# EonaCat.Sync # EonaCat.Sync - Synchronization Service
Synchronisation library Synchronizing files and databases between computers with advanced features including cloud storage, compression, intelligent merging, incremental backups, and REST API support.
## Features
- **File Synchronization**
- Change detection and incremental sync
- SHA256 file integrity verification
- Chunked file transfers for large files
- Configurable exclusion patterns
- Timestamp preservation
- Recursive directory sync
- Retry logic with exponential backoff
- ** File compression (GZip, Deflate, Brotli)**
- **Database Synchronization**
- Entity change tracking and detection
- Batch operations for performance
- Transaction support
- Multi-database support (SQL Server, SQLite, etc.)
- Change logging and tracking
- Index rebuild capabilities
- Foreign key constraint control
- ** Entity Framework Core support (optional)**
- **Cloud Storage Integration**
- Azure Blob Storage support
- AWS S3 integration
- Generic cloud provider interface
- File upload/download with metadata
- Shared access link generation
- **Documentation: Cloud providers are available as optional extensions**
- **Advanced Merging**
- Line-based 3-way merge for text files
- XML/config file intelligent merging
- Automatic conflict detection and resolution
- Multiple merge strategies
- **Backup & Versioning**
- Full and incremental backup support
- Automatic change detection
- Version history tracking
- Point-in-time restore capability
- Retention policies
- **Conflict Resolution**
- Last-write-wins strategy
- Source/Target wins strategies
- Manual resolution support
- Merge capabilities
- Customizable conflict handling
- **Monitoring & Logging**
- Performance metrics collection
- System health checks
- Operation profiling
- Structured logging
- Docker container support
- **Session Management**
- Tracked sync sessions
- Progress notifications
- Error handling and reporting
- Change history tracking
- **REST API**
- Async sync operations
- Cloud storage management
- Backup operations
- System health monitoring
## Installation
Add to your project:
```bash
dotnet add package EonaCat.Sync
```
Optional packages:
```bash
dotnet add package Azure.Storage.Blobs # For Azure support
dotnet add package AWSSDK.S3 # For AWS S3 support
dotnet add package Microsoft.EntityFrameworkCore # For EF Core support
```
## Quick Start
### Basic File Synchronization
```csharp
using EonaCat.Sync;
using EonaCat.Sync.Services;
// Create sync service
var syncService = SyncServiceFactory.CreateSyncService();
// Sync files
var result = await syncService.SyncFilesAsync(
@"C:\SourceFolder",
@"C:\TargetFolder");
Console.WriteLine($"Changes applied: {result.ChangesApplied}");
```
### File Compression
```csharp
using EonaCat.Sync.Compression;
var compressionService = new CompressionService();
// Compress a file
await compressionService.CompressFileAsync(
@"C:\large-file.dat",
@"C:\compressed.gz",
CompressionAlgorithm.GZip);
// Get compression ratio
var ratio = await compressionService.GetCompressionRatioAsync(
@"C:\large-file.dat",
@"C:\compressed.gz");
Console.WriteLine($"Compression ratio: {ratio:F2}%");
```
### Advanced Merging
```csharp
using EonaCat.Sync.Merge;
var mergeService = new MergeService();
// Perform 3-way merge
var result = await mergeService.MergeFilesAsync(
@"C:\base.txt",
@"C:\source.txt",
@"C:\target.txt");
if (result.Conflicts.Count > 0)
{
Console.WriteLine($"Merge conflicts found: {result.Conflicts.Count}");
}
Console.WriteLine(result.MergedContent);
```
### Incremental Backups
```csharp
using EonaCat.Sync.Backup;
var backupService = new IncrementalBackupService();
// Create full backup
var fullBackup = await backupService.CreateFullBackupAsync(
@"C:\ImportantData",
@"D:\Backups");
// Later: Create incremental backup
var incrementalBackup = await backupService.CreateIncrementalBackupAsync(
@"C:\ImportantData",
@"D:\Backups");
Console.WriteLine($"Changed files: {incrementalBackup.ChangedFiles.Count}");
// List all versions
var versions = await backupService.ListVersionsAsync(@"D:\Backups");
// Restore a specific version
await backupService.RestoreVersionAsync(
@"D:\Backups",
fullBackup.VersionId,
@"C:\Restored");
```
### Monitoring & Metrics
```csharp
using EonaCat.Sync.Monitoring;
var metricsCollector = new SyncMetricsCollector();
var logger = new ConsoleStructuredLogger();
// Start operation
var metric = metricsCollector.StartOperation("FileSyncOperation");
// Do work...
var result = await syncService.SyncFilesAsync(source, target);
metric.FilesProcessed = result.ChangesApplied;
metric.ErrorCount = result.Errors.Count;
metricsCollector.EndOperation(metric);
// Get metrics
var aggregateMetrics = metricsCollector.GetAggregateMetrics();
logger.LogInformation($"Success Rate: {aggregateMetrics.SuccessRate:F2}%");
```
## Advanced Configuration
### Enable Compression During Sync
```csharp
var fileSyncOptions = new FileSyncOptions
{
CompressTransfers = true,
CompressionThreshold = 1048576, // 1MB
ChunkSize = 5242880 // 5MB
};
var syncService = SyncServiceFactory.CreateFileSyncService(fileSyncOptions);
```
### Database Sync with EF Core
```csharp
// When Microsoft.EntityFrameworkCore is installed
using EonaCat.Sync.EntityFramework;
var sourceContext = new MyDbContext(sourceConnection);
var targetContext = new MyDbContext(targetConnection);
var result = await EFCoreSynchronizer.SyncDbContextAsync(
sourceContext,
targetContext);
```
### Custom Cloud Provider
```csharp
public class CustomCloudProvider : CloudProviderBase
{
public override CloudProviderType ProviderType => CloudProviderType.Generic;
// Implement abstract methods
}
// Register with factory
CloudProviderFactory.RegisterProvider(provider);
```
### Custom Merge Strategy
```csharp
public class CustomMergeStrategy : IMergeStrategy
{
public string Name => "Custom Merge";
public bool CanHandle(string filePath) => filePath.EndsWith(".custom");
public async Task<MergeResult> MergeAsync(string baseFile, string sourceFile, string targetFile)
{
// Custom merge logic
}
}
// Use with service
var mergeService = new MergeService();
mergeService.RegisterStrategy(new CustomMergeStrategy());
```
## Installation
Add to your project:
```bash
dotnet add package EonaCat.Sync
```
## Quick Start
### Basic File Synchronization
```csharp
using EonaCat.Sync;
using EonaCat.Sync.Services;
// Create sync service
var syncService = SyncServiceFactory.CreateSyncService();
// Sync files
var result = await syncService.SyncFilesAsync(
@"C:\SourceFolder",
@"C:\TargetFolder");
Console.WriteLine($"Changes applied: {result.ChangesApplied}");
Console.WriteLine($"Success: {result.Success}");
```
### Basic Database Synchronization
```csharp
var options = new DatabaseSyncOptions
{
UseTransactions = true,
DatabaseBatchSize = 1000
};
var syncService = SyncServiceFactory.CreateDatabaseSyncService(options);
var result = await syncService.SyncDatabaseAsync(
"Server=SourceServer;Database=SourceDB;Integrated Security=true;",
"Server=TargetServer;Database=TargetDB;Integrated Security=true;",
new[] { "Users", "Products", "Orders" });
Console.WriteLine($"Database sync complete. Success: {result.Success}");
```
### Full Synchronization (Files + Database)
```csharp
var options = new SyncOptions
{
ConflictResolutionStrategy = "LastWriteWins",
DeleteMissingFilesInTarget = true,
ValidateAfterSync = true
};
var syncService = SyncServiceFactory.CreateSyncService();
var result = await syncService.SyncFullAsync(
@"C:\System1\Data",
@"C:\System2\Data",
"Server=System1;Database=AppDB;",
"Server=System2;Database=AppDB;",
new[] { "Users", "Settings", "Documents" },
options);
```
### Bidirectional Synchronization
```csharp
var options = new SyncOptions
{
BidirectionalSync = true,
ConflictResolutionStrategy = "LastWriteWins"
};
var result = await syncService.SyncBidirectionalAsync(
@"C:\Location1",
@"C:\Location2",
options);
```
## Configuration
### FileSyncOptions
```csharp
var fileSyncOptions = new FileSyncOptions
{
// Conflict resolution: "LastWriteWins", "SourceWins", "TargetWins", "Manual"
ConflictResolutionStrategy = "LastWriteWins",
// Delete files from target if they don't exist in source
DeleteMissingFilesInTarget = false,
// Validate data after sync
ValidateAfterSync = true,
// Maximum retry attempts for failed operations
MaxRetries = 3,
// Timeout in seconds
TimeoutSeconds = 300,
// File patterns to exclude (semicolon-separated)
ExcludeFilePatterns = "*.tmp;*.temp;*.bak;*.lock",
// Buffer size for file operations (bytes)
BufferSizeBytes = 65536,
// Preserve original file timestamps
PreserveTimestamps = true,
// Verify file integrity using SHA256
VerifyFileIntegrity = true,
// Compress files during transfer
CompressTransfers = false,
// Minimum file size for compression (bytes)
CompressionThreshold = 1048576,
// Chunk size for large file transfers (bytes)
ChunkSize = 5242880 // 5MB
};
var syncService = SyncServiceFactory.CreateFileSyncService(fileSyncOptions);
```
### DatabaseSyncOptions
```csharp
var dbSyncOptions = new DatabaseSyncOptions
{
// Use transactions for each batch
UseTransactions = true,
// Batch size for database operations
DatabaseBatchSize = 1000,
// Comma-separated list of entities to sync
EntitiesToSync = "Users,Products,Orders",
// Clear target database before sync
ClearTargetBeforeSync = false,
// Rebuild indexes after sync
RebuildIndexesAfterSync = false,
// Bypass foreign key constraints during sync
BypassForeignKeyConstraints = false,
// Conflict resolution strategy
ConflictResolutionStrategy = "LastWriteWins"
};
var syncService = SyncServiceFactory.CreateDatabaseSyncService(dbSyncOptions);
```
## Advanced Usage
### Custom Notifications
```csharp
public class CustomSyncNotifier : ISyncNotifier
{
public void NotifyProgress(string message, int percentage)
{
Console.WriteLine($"Progress: {percentage}% - {message}");
}
public void NotifyError(string errorMessage)
{
Console.WriteLine($"Error: {errorMessage}");
}
public void NotifyCompletion(SyncResult result)
{
Console.WriteLine($"Sync complete. Changes: {result.ChangesApplied}");
}
public void NotifyConflict(SyncConflict conflict)
{
Console.WriteLine($"Conflict detected in {conflict.EntityIdentifier}");
}
}
var notifier = new CustomSyncNotifier();
var syncService = SyncServiceFactory.CreateSyncService(notifier);
```
### Session Management
```csharp
// Start a sync session
var session = await syncService.StartSyncSessionAsync("System1", "System2");
Console.WriteLine($"Session started: {session.SessionId}");
// Perform sync operations
var result = await syncService.SyncFilesAsync(source, target);
// Complete session
await syncService.CompleteSyncSessionAsync(session.SessionId);
// Get session status
var sessionStatus = await syncService.GetSyncSessionAsync(session.SessionId);
```
### Change Tracking
```csharp
// Create a file synchronizer
var fileSynchronizer = new FileSynchronizer();
// Detect changes since a specific time
var changes = await fileSynchronizer.DetectFileChangesAsync(
@"C:\MyFolder",
DateTime.UtcNow.AddHours(-1));
foreach (var change in changes)
{
Console.WriteLine($"Change: {change.SourceId} - {change.Type}");
}
```
### File Metadata
```csharp
var fileSynchronizer = new FileSynchronizer();
// Get file metadata
var metadata = await fileSynchronizer.GetFileMetadataAsync(@"C:\MyFile.dat");
Console.WriteLine($"File: {metadata.FilePath}");
Console.WriteLine($"Size: {metadata.FileSize} bytes");
Console.WriteLine($"Hash: {metadata.FileHash}");
Console.WriteLine($"Modified: {metadata.LastModified}");
```
### Custom Conflict Resolution
```csharp
public class CustomConflictResolver : IConflictResolver
{
public async Task<object> ResolveConflictAsync(SyncConflict conflict)
{
// Custom logic to resolve conflicts
if (conflict.SourceLastModified > conflict.TargetLastModified)
return conflict.SourceValue;
else
return conflict.TargetValue;
}
public string GetResolutionStrategy(ChangeType changeType)
{
return "CustomLogic";
}
}
```
## Error Handling
```csharp
try
{
var result = await syncService.SyncFilesAsync(source, target);
if (!result.Success)
{
foreach (var error in result.Errors)
{
Console.WriteLine($"Error: {error}");
}
}
}
catch (Exception ex)
{
Console.WriteLine($"Sync failed: {ex.Message}");
}
```
## Best Practices
1. **Always validate connection strings** before starting database sync
2. **Use transactions** for database operations to ensure consistency
3. **Enable file integrity verification** for critical files
4. **Set appropriate timeouts** based on network conditions
5. **Monitor progress** for long-running syncs
6. **Test conflict resolution strategies** before production use
7. **Backup target systems** before destructive sync operations
8. **Use bidirectional sync cautiously** to avoid infinite loops
docker-compose.yml
+149
View File
@@ -0,0 +1,149 @@
version: '3.8'
services:
# Main Sync Service
sync-service:
build:
context: .
dockerfile: Dockerfile
container_name: eonacat-sync
ports:
- "5000:80"
environment:
- DOTNET_ENVIRONMENT=Production
- SYNC_DATA_PATH=/data/sync
- SYNC_BACKUP_PATH=/data/backups
- SYNC_LOG_PATH=/data/logs
- ConnectionStrings__DefaultConnection=Server=sqlserver;Database=EonaCat;User Id=sa;Password=${SA_PASSWORD};
volumes:
- sync-data:/data/sync
- sync-backups:/data/backups
- sync-logs:/data/logs
depends_on:
- sqlserver
networks:
- sync-network
restart: unless-stopped
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost/health"]
interval: 30s
timeout: 3s
retries: 3
start_period: 40s
# SQL Server Database
sqlserver:
image: mcr.microsoft.com/mssql/server:2019-latest
container_name: eonacat-sqlserver
environment:
- SA_PASSWORD=${SA_PASSWORD:-SecurePassword123!}
- ACCEPT_EULA=Y
- MSSQL_PID=Express
ports:
- "1433:1433"
volumes:
- sqlserver-data:/var/opt/mssql
networks:
- sync-network
restart: unless-stopped
healthcheck:
test: ["/opt/mssql-tools/bin/sqlcmd", "-S", "localhost", "-U", "sa", "-P", "${SA_PASSWORD}", "-Q", "select 1"]
interval: 15s
timeout: 3s
retries: 5
start_period: 10s
# Redis Cache (Optional)
redis:
image: redis:7-alpine
container_name: eonacat-redis
ports:
- "6379:6379"
volumes:
- redis-data:/data
networks:
- sync-network
restart: unless-stopped
command: redis-server --appendonly yes
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 10s
timeout: 3s
retries: 3
# Monitoring - Prometheus (Optional)
prometheus:
image: prom/prometheus:latest
container_name: eonacat-prometheus
ports:
- "9090:9090"
volumes:
- ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml
- prometheus-data:/prometheus
networks:
- sync-network
restart: unless-stopped
command:
- '--config.file=/etc/prometheus/prometheus.yml'
- '--storage.tsdb.path=/prometheus'
# Monitoring - Grafana (Optional)
grafana:
image: grafana/grafana:latest
container_name: eonacat-grafana
ports:
- "3000:3000"
environment:
- GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD:-admin}
- GF_INSTALL_PLUGINS=grafana-piechart-panel
volumes:
- grafana-data:/var/lib/grafana
depends_on:
- prometheus
networks:
- sync-network
restart: unless-stopped
# Logging - Elasticsearch (Optional)
elasticsearch:
image: docker.elastic.co/elasticsearch/elasticsearch:8.0.0
container_name: eonacat-elasticsearch
environment:
- discovery.type=single-node
- xpack.security.enabled=false
- "ES_JAVA_OPTS=-Xms512m -Xmx512m"
ports:
- "9200:9200"
volumes:
- elasticsearch-data:/usr/share/elasticsearch/data
networks:
- sync-network
restart: unless-stopped
# Logging - Kibana (Optional)
kibana:
image: docker.elastic.co/kibana/kibana:8.0.0
container_name: eonacat-kibana
ports:
- "5601:5601"
environment:
- ELASTICSEARCH_HOSTS=http://elasticsearch:9200
depends_on:
- elasticsearch
networks:
- sync-network
restart: unless-stopped
networks:
sync-network:
driver: bridge
volumes:
sync-data:
sync-backups:
sync-logs:
sqlserver-data:
redis-data:
prometheus-data:
grafana-data:
elasticsearch-data: