FileIoAccessProvider.cs

using FileSyncLibNet.Commons;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;

namespace FileSyncLibNet.AccessProviders
{
    internal class FileIoAccessProvider : IAccessProvider
    {
        public string AccessPath { get; private set; }
        private readonly RemoteState remoteState;
        private readonly ILogger logger;
        private const int DefaultBandwidthLimit = 100 * 1024 * 1024; // 100 MB/s
        private int bandwidthLimit = DefaultBandwidthLimit;

        public FileIoAccessProvider(ILogger logger, string stateFilename)
        {
            this.logger = logger;
            if (!string.IsNullOrEmpty(stateFilename))
                remoteState = new RemoteState(stateFilename);

        }
        public void UpdateAccessPath(string accessPath)
        {
            AccessPath = accessPath;
        }

        public void CreateDirectory(string path)
        {
            Directory.CreateDirectory(Path.Combine(AccessPath, path));
        }

        public FileInfo2 GetFileInfo(string path)
        {
            if (null != remoteState)
                return remoteState.GetFileInfo(Path.Combine(AccessPath, path));

            var fi = new FileInfo(Path.Combine(AccessPath, path));

            return new FileInfo2(path, fi.Exists)
            {
                LastWriteTime = fi.Exists ? new DateTime(fi.LastWriteTime.Ticks) : DateTime.MinValue,
                Length = fi.Exists ? fi.Length : 0
            };
        }

        public List<FileInfo2> GetFiles(DateTime minimumLastWriteTime, string pattern, string path = null, bool recursive = false, List<string> subfolders = null, bool olderFiles = false)
        {
            DirectoryInfo _di = new DirectoryInfo(AccessPath);
            List<FileInfo2> ret_val = new List<FileInfo2>();
            foreach (var dir in (subfolders != null && subfolders.Count > 0) ? _di.GetDirectories() : new[] { _di })
            {
                try
                {
                    if (subfolders != null && subfolders.Count > 0 && !subfolders.Select(x => x.ToLower()).Contains(dir.Name.ToLower()))
                        continue;
                    var _fi = dir.EnumerateFiles(
                        searchPattern: pattern,
                        searchOption: recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);

                    ret_val.AddRange(_fi.Where(x => (olderFiles ? x.LastWriteTime <= minimumLastWriteTime : x.LastWriteTime >= minimumLastWriteTime))
                        .Select(x => new FileInfo2(x.FullName.Substring(AccessPath.Length + 1), x.Exists) { Length = x.Length, LastWriteTime = x.LastWriteTime })
                        .ToList());
                }
                catch (Exception exc)
                {
                    logger?.LogError(exc, "exception in GetFiles for path {A}, dir {B}", path, dir);
                }
            }
            return ret_val;
        }

        public Stream GetStream(FileInfo2 file)
        {
            var realFilename = Path.Combine(AccessPath, file.Name);
            return File.OpenRead(realFilename);
        }

        public void WriteFile(FileInfo2 file, Stream content)
        {
            var realFilename = Path.Combine(AccessPath, file.Name);
            Directory.CreateDirectory(Path.GetDirectoryName(realFilename));
            if (bandwidthLimit == DefaultBandwidthLimit)
            {
                using (var stream = File.Create(realFilename))
                {
                    content.CopyTo(stream);
                }
            }
            else
            {
                using (var stream = new FileStream(realFilename, FileMode.Create, FileAccess.Write, FileShare.None, 4096, FileOptions.None))
                {
                    int sleepIntervalMs = 50; // Fixed sleep interval
                    int bufferSize = bandwidthLimit / (1000 / sleepIntervalMs); // Calculate buffer size based on bandwidth limit and interval
                    byte[] buffer = new byte[bufferSize];
                    int bytesRead;

                    while ((bytesRead = content.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        stream.Write(buffer, 0, bytesRead);
                        Thread.Sleep(sleepIntervalMs); // Sleep for the fixed interval
                    }
                }
            }
            File.SetLastWriteTime(realFilename, file.LastWriteTime);
            remoteState?.SetFileInfo(realFilename, file);
        }
        public void Delete(FileInfo2 fileInfo)
        {
            var realFilename = Path.Combine(AccessPath, fileInfo.Name);
            File.Delete(realFilename);
            remoteState?.RemoveFileInfo(realFilename);
        }
    }
}