Added new file manager, renamed websites to webspaces. Added cloudpanel integration partialy. Added generic repos and more stuff

Moonlight/App/Helpers/Files/SftpFileAccess.cs

@@ -0,0 +1,206 @@
+using Logging.Net;
+using Renci.SshNet;
+using ConnectionInfo = Renci.SshNet.ConnectionInfo;
+
+namespace Moonlight.App.Helpers.Files;
+
+public class SftpFileAccess : FileAccess
+{
+    private readonly string SftpHost;
+    private readonly string SftpUser;
+    private readonly string SftpPassword;
+    private readonly int SftpPort;
+    private readonly bool ForceUserDir;
+
+    private readonly SftpClient Client;
+
+    private string InternalPath
+    {
+        get
+        {
+            if (ForceUserDir)
+                return $"/home/{SftpUser}{CurrentPath}";
+
+            return InternalPath;
+        }
+    }
+
+    public SftpFileAccess(string sftpHost, string sftpUser, string sftpPassword, int sftpPort,
+        bool forceUserDir = false)
+    {
+        SftpHost = sftpHost;
+        SftpUser = sftpUser;
+        SftpPassword = sftpPassword;
+        SftpPort = sftpPort;
+        ForceUserDir = forceUserDir;
+
+        Client = new(
+            new ConnectionInfo(
+                SftpHost,
+                SftpPort,
+                SftpUser,
+                new PasswordAuthenticationMethod(
+                    SftpUser,
+                    SftpPassword
+                )
+            )
+        );
+    }
+
+    private void EnsureConnect()
+    {
+        if (!Client.IsConnected)
+            Client.Connect();
+    }
+
+
+    public override Task<FileData[]> Ls()
+    {
+        EnsureConnect();
+
+        var x = new List<FileData>();
+
+        foreach (var file in Client.ListDirectory(InternalPath))
+        {
+            if (file.Name != "." && file.Name != "..")
+            {
+                x.Add(new()
+                {
+                    Name = file.Name,
+                    Size = file.Attributes.Size,
+                    IsFile = !file.IsDirectory
+                });
+            }
+        }
+
+        return Task.FromResult(x.ToArray());
+    }
+
+    public override Task Cd(string dir)
+    {
+        var x = Path.Combine(CurrentPath, dir).Replace("\\", "/") + "/";
+        x = x.Replace("//", "/");
+        CurrentPath = x;
+
+        return Task.CompletedTask;
+    }
+
+    public override Task Up()
+    {
+        CurrentPath = Path.GetFullPath(Path.Combine(CurrentPath, "..")).Replace("\\", "/").Replace("C:", "");
+        return Task.CompletedTask;
+    }
+
+    public override Task SetDir(string dir)
+    {
+        CurrentPath = dir;
+        return Task.CompletedTask;
+    }
+
+    public override Task<string> Read(FileData fileData)
+    {
+        EnsureConnect();
+
+        var textStream = Client.Open(InternalPath.TrimEnd('/') + "/" + fileData.Name, FileMode.Open);
+
+        if (textStream == null)
+            return Task.FromResult("");
+
+        var streamReader = new StreamReader(textStream);
+
+        var text = streamReader.ReadToEnd();
+
+        streamReader.Close();
+        textStream.Close();
+
+        return Task.FromResult(text);
+    }
+
+    public override Task Write(FileData fileData, string content)
+    {
+        EnsureConnect();
+
+        var textStream = Client.Open(InternalPath.TrimEnd('/') + "/" + fileData.Name, FileMode.Create);
+
+        var streamWriter = new StreamWriter(textStream);
+        streamWriter.Write(content);
+
+        streamWriter.Flush();
+        textStream.Flush();
+
+        streamWriter.Close();
+        textStream.Close();
+
+        return Task.CompletedTask;
+    }
+
+    public override async Task Upload(string name, Stream stream, Action<int>? progressUpdated = null)
+    {
+        var dataStream = new SyncStreamAdapter(stream);
+        
+        await Task.Factory.FromAsync((x, _) => Client.BeginUploadFile(dataStream, InternalPath + name, x, null, u =>
+            {
+                progressUpdated?.Invoke((int)((long)u / stream.Length));
+            }),
+            Client.EndUploadFile, null);
+    }
+
+    public override Task MkDir(string name)
+    {
+        Client.CreateDirectory(InternalPath + name);
+
+        return Task.CompletedTask;
+    }
+
+    public override Task<string> Pwd()
+    {
+        return Task.FromResult(CurrentPath);
+    }
+
+    public override Task<string> DownloadUrl(FileData fileData)
+    {
+        throw new NotImplementedException();
+    }
+
+    public override Task<Stream> DownloadStream(FileData fileData)
+    {
+        var stream = new MemoryStream(100 * 1024 * 1024);
+        Client.DownloadFile(InternalPath + fileData.Name, stream);
+
+        return Task.FromResult<Stream>(stream);
+    }
+
+    public override Task Delete(FileData fileData)
+    {
+        Client.Delete(InternalPath + fileData.Name);
+
+        return Task.CompletedTask;
+    }
+
+    public override Task Move(FileData fileData, string newPath)
+    {
+        Client.RenameFile(InternalPath + fileData.Name, InternalPath + newPath);
+
+        return Task.CompletedTask;
+    }
+
+    public override Task Compress(params FileData[] files)
+    {
+        throw new NotImplementedException();
+    }
+
+    public override Task Decompress(FileData fileData)
+    {
+        throw new NotImplementedException();
+    }
+
+    public override Task<string> GetLaunchUrl()
+    {
+        return Task.FromResult($"sftp://{SftpUser}@{SftpHost}:{SftpPort}");
+    }
+
+    public override object Clone()
+    {
+        return new SftpFileAccess(SftpHost, SftpUser, SftpPassword, SftpPort, ForceUserDir);
+    }
+}

Moonlight/App/Helpers/SyncStreamAdapter.cs

@@ -0,0 +1,58 @@
+namespace Moonlight.App.Helpers;
+
+public class SyncStreamAdapter : Stream
+{
+    private readonly Stream _stream;
+
+    public SyncStreamAdapter(Stream stream)
+    {
+        _stream = stream ?? throw new ArgumentNullException(nameof(stream));
+    }
+
+    public override bool CanRead => _stream.CanRead;
+    public override bool CanSeek => _stream.CanSeek;
+    public override bool CanWrite => _stream.CanWrite;
+    public override long Length => _stream.Length;
+
+    public override long Position
+    {
+        get => _stream.Position;
+        set => _stream.Position = value;
+    }
+
+    public override void Flush()
+    {
+        _stream.Flush();
+    }
+
+    public override int Read(byte[] buffer, int offset, int count)
+    {
+        var task = Task.Run(() => _stream.ReadAsync(buffer, offset, count));
+        return task.GetAwaiter().GetResult();
+    }
+
+    public override long Seek(long offset, SeekOrigin origin)
+    {
+        return _stream.Seek(offset, origin);
+    }
+
+    public override void SetLength(long value)
+    {
+        _stream.SetLength(value);
+    }
+
+    public override void Write(byte[] buffer, int offset, int count)
+    {
+        var task = Task.Run(() => _stream.WriteAsync(buffer, offset, count));
+        task.GetAwaiter().GetResult();
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _stream?.Dispose();
+        }
+        base.Dispose(disposing);
+    }
+}