path: root/Software/Visual_Studio/FSE/Tango.FSE.UI/FileSystem/DefaultFileSystemProvider.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Tango.Core;
using Tango.Core.IO;
using Tango.Core.Threading;
using Tango.FileSystem;
using Tango.FileSystem.Network;
using Tango.FSE.Common.Connection;
using Tango.FSE.Common.FileSystem;
using Tango.Transport;
using Tango.Transport.Transporters;
using Tango.WebRTC;

namespace Tango.FSE.UI.FileSystem
{
    public class DefaultFileSystemProvider : ExtendedObject, IFileSystemProvider
    {
        private IMachineProvider _machineProvider;
        private BasicTransporter _webRtcTransporter;
        private const string WEB_RTC_CHANNEL_NAME = "FileSystemChannel";
        private const long MAX_CHUNK_SIZE = 1024 * 100;
        private const long MIN_CHUNK_SIZE = 1024;
        private const long MAX_CHUNK_SIZE_WEB_RTC = 1024 * 50;
        private const int WEB_RTC_MAX_RETRIES = 8;
        private List<FileSystemHandler> _activeHandlers;

        private bool _enableWebRTC;
        public bool EnableWebRTC
        {
            get { return _enableWebRTC; }
            set { _enableWebRTC = value; RaisePropertyChangedAuto(); }
        }

        private bool _isWebRtcAvailable;
        public bool IsWebRtcAvailable
        {
            get { return _isWebRtcAvailable; }
            private set { _isWebRtcAvailable = value; RaisePropertyChangedAuto(); }
        }

        public DefaultFileSystemProvider(IMachineProvider machineProvider)
        {
            _activeHandlers = new List<FileSystemHandler>();

            EnableWebRTC = true; //TODO: From Settings..
            _machineProvider = machineProvider;
            _machineProvider.MachineConnected += _machineProvider_MachineConnected;
            _machineProvider.MachineDisconnected += _machineProvider_MachineDisconnected;
        }

        private async void _machineProvider_MachineDisconnected(object sender, MachineDisconnectedEventArgs e)
        {
            IsWebRtcAvailable = false;

            foreach (var handler in _activeHandlers.ToList())
            {
                try
                {
                    handler.RaiseFailed(new TransporterDisconnectedException("Machine disconnected."));
                }
                catch (Exception ex)
                {
                    Debug.WriteLine(ex);
                }
            }

            _activeHandlers.Clear();

            if (_webRtcTransporter != null)
            {
                try
                {
                    LogManager.Log("Machine disconnected. Disconnecting FileSystem WebRTC Transporter...");
                    await _webRtcTransporter.Disconnect();
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error while disconnecting FileSystem WebRTC Transporter.");
                }
            }
        }

        private async void _machineProvider_MachineConnected(object sender, MachineConnectedEventArgs e)
        {
            if (EnableWebRTC)
            {
                try
                {
                    IsWebRtcAvailable = false;

                    await _machineProvider.MachineOperator.SendGenericRequest<InitWebRtcRequest, InitWebRtcResponse>(new InitWebRtcRequest()
                    {
                        DataChannelName = WEB_RTC_CHANNEL_NAME
                    }, new TransportRequestConfig()
                    {
                        Timeout = TimeSpan.FromSeconds(60),
                        Priority = QueuePriority.Low
                    });

                    _webRtcTransporter = new BasicTransporter(new WebRtcTransportAdapter(_machineProvider.MachineOperator, WebRtcTransportAdapterMode.Active, WEB_RTC_CHANNEL_NAME));
                    _webRtcTransporter.UseKeepAlive = false;
                    _webRtcTransporter.ComponentName = "File System Active WebRTC Transporter";
                    await _webRtcTransporter.Connect();

                    IsWebRtcAvailable = true;

                    LogManager.Log("FileSystem via WebRTC is ready.");
                }
                catch (Exception ex)
                {
                    IsWebRtcAvailable = false;
                    LogManager.Log(ex, "Error initializing FileSystem via WebRTC.");
                }
            }
        }

        public async Task<IFileSystemContainer> GetFolder(string path)
        {
            var response = await _machineProvider.MachineOperator.SendGenericRequest<GetFileSystemItemRequest, GetFileSystemItemResponse>(new GetFileSystemItemRequest()
            {
                Path = path
            }, new TransportRequestConfig()
            {
                Timeout = TimeSpan.FromSeconds(30),
            });

            return FileSystemItem.FromDTO(response.FileSystemItem) as IFileSystemContainer;
        }

        public async Task<IFileSystemContainer> GetSpecialFolder(Environment.SpecialFolder specialFolder)
        {
            var response = await _machineProvider.MachineOperator.SendGenericRequest<GetFileSystemItemRequest, GetFileSystemItemResponse>(new GetFileSystemItemRequest()
            {
                SpecialFolder = specialFolder
            }, new TransportRequestConfig()
            {
                Timeout = TimeSpan.FromSeconds(30),
            });

            return FileSystemItem.FromDTO(response.FileSystemItem) as IFileSystemContainer;
        }

        public async Task<IFileSystemContainer> GetThisPC()
        {
            var response = await _machineProvider.MachineOperator.SendGenericRequest<GetFileSystemItemRequest, GetFileSystemItemResponse>(new GetFileSystemItemRequest()
            {
                //No parameters at all
            }, new TransportRequestConfig()
            {
                Timeout = TimeSpan.FromSeconds(30),
            });

            return FileSystemItem.FromDTO(response.FileSystemItem) as IFileSystemContainer;
        }

        public Task<FileSystemHandler> Download(FileSystemItem item, string localTargetFolder)
        {
            String operationId = String.Empty;
            String destination = String.Empty;
            long downloadLength = 0;
            bool aborted = false;

            FileSystemHandler handler = null;

            destination = Path.Combine(localTargetFolder, item.Name);


            handler = new FileSystemHandler(item.Type == FileSystemItemType.Folder ? FileSystemHandlerType.FolderDownload : FileSystemHandlerType.FileDownload, item, destination, async () =>
            {
                if (!aborted)
                {
                    aborted = true;
                    try
                    {
                        var response = await _machineProvider.MachineOperator.SendGenericRequest<AbortOperationRequest, AbortOperationResponse>(
                        new AbortOperationRequest()
                        {
                            OperationId = operationId
                        }, new TransportRequestConfig() { Timeout = TimeSpan.FromSeconds(30) });
                    }
                    catch (Exception ex)
                    {
                        LogManager.Log(ex, "Error aborting the download operation.");
                    }
                    finally
                    {
                        handler.RaiseAborted();
                    }
                }
            });

            _activeHandlers.Add(handler);

            ThreadFactory.StartNew(async () =>
            {
                try
                {
                    if (item.Type == FileSystemItemType.File)
                    {
                        var response = await _machineProvider.MachineOperator.SendGenericRequest<FileDownloadRequest, FileDownloadResponse>(
                            new FileDownloadRequest()
                            {
                                Path = item.Path
                            }, new TransportRequestConfig() { Timeout = TimeSpan.FromSeconds(20) });

                        operationId = response.OperationId;
                        downloadLength = response.Length;
                        handler.OperationId = operationId;
                    }
                    else if (item.Type == FileSystemItemType.Folder)
                    {
                        var response = await _machineProvider.MachineOperator.SendGenericRequest<FolderDownloadRequest, FolderDownloadResponse>(
                            new FolderDownloadRequest()
                            {
                                Path = item.Path
                            }, new TransportRequestConfig() { Timeout = TimeSpan.FromSeconds(60) });

                        operationId = response.OperationId;
                        downloadLength = response.Length;
                        handler.OperationId = operationId;
                    }
                    else
                    {
                        throw new NotSupportedException("The requested file system item is not supported for downloading.");
                    }
                }
                catch (Exception ex)
                {
                    _activeHandlers.Remove(handler);
                    handler.RaiseFailed(ex);
                    return;
                }

                long position = 0;
                bool webRtcFailed = false;
                int webRtcRetries = WEB_RTC_MAX_RETRIES;
                long dynamixMaxChunkSizeSignalR = MAX_CHUNK_SIZE;

                var tempFile = TemporaryManager.CreateFile();

                while (position < downloadLength && !aborted)
                {
                    if (handler.IsPaused)
                    {
                        Thread.Sleep(1000);
                        continue;
                    }

                    try
                    {
                        ChunkDownloadResponse response = null;
                        ChunkDownloadRequest request = new ChunkDownloadRequest()
                        {
                            MaxChunkSize = MAX_CHUNK_SIZE,
                            OperationId = operationId,
                            Position = position,
                        };

                        if (_webRtcTransporter != null && _webRtcTransporter.State == TransportComponentState.Connected && EnableWebRTC && !webRtcFailed)
                        {
                            try
                            {
                                request.MaxChunkSize = MAX_CHUNK_SIZE_WEB_RTC;
                                response = await _webRtcTransporter.SendGenericRequest<ChunkDownloadRequest, ChunkDownloadResponse>(request, new TransportRequestConfig()
                                {
                                    Timeout = TimeSpan.FromSeconds(2),
                                    Priority = QueuePriority.Low
                                });

                                webRtcRetries = WEB_RTC_MAX_RETRIES;
                            }
                            catch (Exception ex)
                            {
                                webRtcRetries--;

                                if (webRtcRetries == 0)
                                {
                                    webRtcFailed = true;
                                    LogManager.Log(ex, "WebRTC chunk download failed. Falling back to standard download...");
                                }

                                continue;
                            }
                        }
                        else
                        {
                            request.MaxChunkSize = dynamixMaxChunkSizeSignalR;

                            Stopwatch watch = new Stopwatch();
                            watch.Start();

                            response = await _machineProvider.MachineOperator.SendGenericRequest<ChunkDownloadRequest, ChunkDownloadResponse>(request, new TransportRequestConfig()
                            {
                                Timeout = TimeSpan.FromSeconds(30),
                                Priority = QueuePriority.Low
                            });

                            watch.Stop();

                            if (watch.Elapsed.TotalSeconds < 1)
                            {
                                dynamixMaxChunkSizeSignalR += 1024 * 10;
                            }
                            else if (watch.Elapsed.TotalSeconds > 1)
                            {
                                dynamixMaxChunkSizeSignalR -= 1024 * 10;
                            }

                            dynamixMaxChunkSizeSignalR = Math.Max(dynamixMaxChunkSizeSignalR, MIN_CHUNK_SIZE);
                        }

                        using (FileStream fs = new FileStream(tempFile, FileMode.Append))
                        {
                            fs.Write(response.Data, 0, response.Data.Length);
                        }

                        position += response.Data.Length;
                        handler.InvalidateProgress(position, downloadLength);
                    }
                    catch (Exception ex)
                    {
                        _activeHandlers.Remove(handler);
                        tempFile.Delete();
                        handler.RaiseFailed(ex);
                        return;
                    }
                }

                if (!aborted)
                {
                    try
                    {
                        if (item.Type == FileSystemItemType.File)
                        {
                            File.Copy(tempFile, destination, true);
                            tempFile.Delete();
                        }
                        else if (item.Type == FileSystemItemType.Folder)
                        {
                            using (Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile(tempFile))
                            {
                                zip.ExtractAll(destination, Ionic.Zip.ExtractExistingFileAction.OverwriteSilently);
                            }

                            tempFile.Delete();
                        }

                        handler.RaiseCompleted();
                    }
                    catch (Exception ex)
                    {
                        handler.RaiseFailed(ex);
                    }
                }
                else
                {
                    tempFile.Delete();
                }

                _activeHandlers.Remove(handler);
            });

            return Task.FromResult(handler);
        }

        public Task<FileSystemHandler> Upload(String localSourcePath, FileSystemItem remoteFolder)
        {
            String operationId = String.Empty;
            String destination = Path.Combine(remoteFolder.Path, Path.GetFileName(localSourcePath));
            bool isFolder = false;
            bool aborted = false;

            FileSystemItem sourceItem = null;

            if (Directory.Exists(localSourcePath))
            {
                sourceItem = new FolderItem() { Path = localSourcePath };
                isFolder = true;
            }
            else if (File.Exists(localSourcePath))
            {
                sourceItem = new FileItem() { Path = localSourcePath };
                isFolder = false;
            }
            else
            {
                throw new FileNotFoundException("Could not locate the local file or directory to upload.");
            }

            FileSystemHandler handler = null;

            handler = new FileSystemHandler(isFolder ? FileSystemHandlerType.FolderUpload : FileSystemHandlerType.FileUpload, sourceItem, destination, async () =>
             {
                 if (!aborted)
                 {
                     aborted = true;
                     try
                     {
                         var response = await _machineProvider.MachineOperator.SendGenericRequest<AbortOperationRequest, AbortOperationResponse>(
                         new AbortOperationRequest()
                         {
                             OperationId = operationId
                         }, new TransportRequestConfig() { Timeout = TimeSpan.FromSeconds(30) });
                     }
                     catch (Exception ex)
                     {
                         LogManager.Log(ex, "Error aborting the upload operation.");
                     }
                     finally
                     {
                         handler.RaiseAborted();
                     }
                 }
             });

            _activeHandlers.Add(handler);

            ThreadFactory.StartNew(async () =>
            {
                try
                {
                    if (!isFolder)
                    {
                        var response = await _machineProvider.MachineOperator.SendGenericRequest<FileUploadRequest, FileUploadResponse>(
                            new FileUploadRequest()
                            {
                                Path = destination
                            }, new TransportRequestConfig() { Timeout = TimeSpan.FromSeconds(20) });

                        operationId = response.OperationId;
                        handler.OperationId = operationId;
                    }
                    else
                    {
                        var response = await _machineProvider.MachineOperator.SendGenericRequest<FolderUploadRequest, FolderUploadResponse>(
                            new FolderUploadRequest()
                            {
                                Path = destination
                            }, new TransportRequestConfig() { Timeout = TimeSpan.FromSeconds(20) });

                        operationId = response.OperationId;
                        handler.OperationId = operationId;
                    }

                    if (isFolder)
                    {
                        var originalPath = localSourcePath;
                        localSourcePath = TemporaryManager.CreateImaginaryFile().Path;
                        ZipFile.CreateFromDirectory(originalPath, localSourcePath);
                    }
                }
                catch (Exception ex)
                {
                    _activeHandlers.Remove(handler);
                    handler.RaiseFailed(ex);
                    return;
                }

                long position = 0;
                bool webRtcFailed = false;
                int webRtcRetries = WEB_RTC_MAX_RETRIES;
                long dynamixMaxChunkSizeSignalR = MAX_CHUNK_SIZE;

                using (FileStream fs = new FileStream(localSourcePath, FileMode.Open))
                {
                    while (position < fs.Length && !aborted)
                    {
                        fs.Position = position;

                        if (handler.IsPaused)
                        {
                            Thread.Sleep(1000);
                            continue;
                        }

                        try
                        {
                            ChunkUploadResponse response = null;
                            ChunkUploadRequest request = new ChunkUploadRequest()
                            {
                                OperationId = operationId,
                            };

                            if (_webRtcTransporter != null && _webRtcTransporter.State == TransportComponentState.Connected && EnableWebRTC && !webRtcFailed)
                            {
                                try
                                {
                                    byte[] data = new byte[Math.Min(MAX_CHUNK_SIZE_WEB_RTC, fs.Length - fs.Position)];
                                    fs.Read(data, 0, data.Length);
                                    request.Data = data;
                                    request.IsCompleted = fs.Position == fs.Length;

                                    response = await _webRtcTransporter.SendGenericRequest<ChunkUploadRequest, ChunkUploadResponse>(request, new TransportRequestConfig()
                                    {
                                        Timeout = request.IsCompleted ? TimeSpan.FromSeconds(120) : TimeSpan.FromSeconds(2),
                                        Priority = QueuePriority.Low
                                    });

                                    webRtcRetries = WEB_RTC_MAX_RETRIES;
                                }
                                catch (Exception ex)
                                {
                                    webRtcRetries--;

                                    if (webRtcRetries == 0)
                                    {
                                        webRtcFailed = true;
                                        LogManager.Log(ex, "WebRTC chunk upload failed. Falling back to standard upload...");
                                    }

                                    continue;
                                }
                            }
                            else
                            {
                                byte[] data = new byte[Math.Min(dynamixMaxChunkSizeSignalR, fs.Length - fs.Position)];
                                fs.Read(data, 0, data.Length);
                                request.Data = data;
                                request.IsCompleted = fs.Position == fs.Length;

                                Stopwatch watch = new Stopwatch();
                                watch.Start();

                                response = await _machineProvider.MachineOperator.SendGenericRequest<ChunkUploadRequest, ChunkUploadResponse>(request, new TransportRequestConfig()
                                {
                                    Timeout = request.IsCompleted ? TimeSpan.FromSeconds(120) : TimeSpan.FromSeconds(30),
                                    Priority = QueuePriority.Low
                                });

                                watch.Stop();

                                if (watch.Elapsed.TotalSeconds < 1)
                                {
                                    dynamixMaxChunkSizeSignalR += 1024 * 10;
                                }
                                else if (watch.Elapsed.TotalSeconds > 1)
                                {
                                    dynamixMaxChunkSizeSignalR -= 1024 * 10;
                                }

                                dynamixMaxChunkSizeSignalR = Math.Max(dynamixMaxChunkSizeSignalR, MIN_CHUNK_SIZE);
                            }

                            position = fs.Position;
                            handler.InvalidateProgress(position, fs.Length);
                        }
                        catch (Exception ex)
                        {
                            _activeHandlers.Remove(handler);
                            handler.RaiseFailed(ex);

                            if (isFolder)
                            {
                                try
                                {
                                    fs.Dispose();
                                    File.Delete(localSourcePath);
                                }
                                catch { }
                            }

                            return;
                        }
                    }

                    if (!aborted)
                    {
                        handler.RaiseCompleted();
                    }

                    if (isFolder)
                    {
                        try
                        {
                            File.Delete(localSourcePath);
                        }
                        catch { }
                    }
                }

                _activeHandlers.Remove(handler);
            });

            return Task.FromResult(handler);
        }

        public async Task Copy(FileSystemItem source, FileSystemItem target)
        {
            if (source.Type == FileSystemItemType.Drive)
            {
                throw new NotSupportedException("The source file system item is not supported for copying.");
            }
            if (target.Type == FileSystemItemType.File)
            {
                throw new NotSupportedException("The target file system item is not a valid container.");
            }

            await _machineProvider.MachineOperator.SendGenericRequest<CopyRequest, CopyResponse>(new CopyRequest()
            {

                Source = source.Path,
                Destination = Path.Combine(target.Path, source.Name)

            }, new TransportRequestConfig()
            {
                Timeout = TimeSpan.FromSeconds(120),
            });
        }

        public async Task Move(FileSystemItem source, FileSystemItem target)
        {
            if (source.Type == FileSystemItemType.Drive)
            {
                throw new NotSupportedException("The source file system item is not supported for copying.");
            }
            if (target.Type == FileSystemItemType.File)
            {
                throw new NotSupportedException("The target file system item is not a valid container.");
            }

            await _machineProvider.MachineOperator.SendGenericRequest<MoveRequest, MoveResponse>(new MoveRequest()
            {

                Source = source.Path,
                Destination = Path.Combine(target.Path, source.Name)

            }, new TransportRequestConfig()
            {
                Timeout = TimeSpan.FromSeconds(120),
            });
        }

        public async Task Rename(FileSystemItem source, string newName)
        {
            if (source.Type == FileSystemItemType.Drive)
            {
                throw new NotSupportedException("The source file system item is not supported for copying.");
            }
            if (newName.ToList().Exists(x => Path.GetInvalidFileNameChars().Contains(x)))
            {
                throw new ArgumentException("The new name contains invalid characters.");
            }

            await _machineProvider.MachineOperator.SendGenericRequest<MoveRequest, MoveResponse>(new MoveRequest()
            {

                Source = source.Path,
                Destination = Path.Combine(Path.GetDirectoryName(source.Path), newName)

            });
        }

        public async Task Delete(FileSystemItem item)
        {
            if (item.Type == FileSystemItemType.Drive)
            {
                throw new NotSupportedException("The source file system item is not supported for deletion.");
            }

            await _machineProvider.MachineOperator.SendGenericRequest<DeleteRequest, DeleteResponse>(new DeleteRequest()
            {
                Path = item.Path
            }, new TransportRequestConfig() { Timeout = TimeSpan.FromSeconds(120) });
        }

        public async Task<FolderItem> CreateFolder(FileSystemItem parent, string folderName)
        {
            var response = await _machineProvider.MachineOperator.SendGenericRequest<CreateFolderRequest, CreateFolderResponse>(new CreateFolderRequest()
            {
                Path = parent.Path,
                FolderName = folderName,
            });

            return FileSystemItem.FromDTO(response.FolderItem) as FolderItem;
        }

        public async Task<PerformDiskSpaceOptimizationResponse> PerformDiskSpaceOptimization()
        {
            var response = await _machineProvider.MachineOperator.SendGenericRequest<PerformDiskSpaceOptimizationRequest, PerformDiskSpaceOptimizationResponse>(new PerformDiskSpaceOptimizationRequest()
            {

            }, new TransportRequestConfig()
            {
                 Timeout = TimeSpan.FromMinutes(5)
            });

            return response;
        }
    }
}