PackageManager/PackageServer/PackageManager.cs

using Force.Crc32;
using PackageInterface;
using System;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Threading.Tasks;

namespace PackageServer
{
    enum PackageTaskState
    {
        Running,
        Transfering,
        Executing,
        Closed,
    }

    class PackageTask
    {
        private uint _transferHashCode;
        private string _transferFolder;
        private string _packageFolder;

        private string _transferFilePath;
        private Stream _transferStream;

        private Process _runningProcess;

        public string Id { get; }

        public string Version { get; }

        public PackageTaskState State { get; private set; }

        public PackageTask(string version, string transferFolder, string packageFolder)
        {
            _transferFolder = transferFolder;
            _packageFolder = packageFolder;
            Id = Guid.NewGuid().ToString("N");
            Version = version;
            State = PackageTaskState.Running;
        }

        public void StartTransfer(uint hashCode)
        {
            if(!Directory.Exists(_transferFolder))
            {
                Directory.CreateDirectory(_transferFolder);
            }
            //Clean the package folder
            if(Directory.Exists(_packageFolder))
            {
                Directory.Delete(_packageFolder, true);
            }
            if(!Directory.Exists(_packageFolder))
            {
                Directory.CreateDirectory(_packageFolder);
            }
            _transferHashCode = hashCode;
            _transferFilePath = Path.Combine(_transferFolder, Guid.NewGuid().ToString("N") + ".zip");
            _transferStream = File.Open(_transferFilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.ReadWrite);
            State = PackageTaskState.Transfering;
        }

        public void AddTransferData(byte[] data)
        {
            try
            {
                _transferStream.Write(data);
            }
            catch
            {
                Close();
                throw;
            }
        }

        public void EndTransfer()
        {
            try
            {
                _transferStream.Flush();
                _transferStream.Dispose();
                var zipData = File.ReadAllBytes(_transferFilePath);
                //check hash code.
                var hashCode = Crc32Algorithm.Compute(zipData);
                if (hashCode != _transferHashCode)
                {
                    throw new InvalidDataException("Transfer hash code is not right.");
                }

                //Extract to package folder.
                ZipFile.ExtractToDirectory(_transferFilePath, _packageFolder, true);
                if (File.Exists(_transferFilePath))
                {
                    File.Delete(_transferFilePath);
                }
                State = PackageTaskState.Running;
            }
            catch
            {
                Close();
                throw;
            }
        }

        public void Execute(string fileName)
        {
            try
            {
                //Execute bat file or exe file.
                var filePath = Path.Combine(_packageFolder, fileName);
                if (!File.Exists(filePath))
                {
                    throw new InvalidDataException("The file is not exist.");
                }
                _runningProcess = Process.Start(new ProcessStartInfo() { FileName = filePath, Arguments=Version, UseShellExecute = true, WorkingDirectory = _packageFolder });
                State = PackageTaskState.Executing;
                Task.Run(() =>
                {
                    _runningProcess.WaitForExit();
                    State = PackageTaskState.Running;
                });
            }
            catch
            {
                Close();
                throw;
            }

        }

        public void Close()
        {
            if(_transferStream != null)
            {
                _transferStream.Dispose();
                _transferStream = null;
            }
            if(File.Exists(_transferFilePath))
            {
                File.Delete(_transferFilePath);
            }
            State = PackageTaskState.Closed;
        }

        /// <summary>
        /// Kill means force kill the running task.
        /// </summary>
        public void Kill()
        {
            if (_runningProcess != null)
            {
                _runningProcess.Kill();
            }
            Close();
            State = PackageTaskState.Closed;
        }
    }

    class Packager
    {
        private string _packagerFolder;
        private string _transferFolder;
        private string _packageFolder;

        public string Id { get; }

        public string ProjectName { get; }

        public PackageTask CurrentTask { get; private set; }

        public Packager(string projectName)
        {
            Id = Guid.NewGuid().ToString("N");
            ProjectName = projectName;
            _packagerFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Packages", ProjectName);
            if(!Directory.Exists(_packagerFolder))
            {
                Directory.CreateDirectory(_packagerFolder);
            }
            _transferFolder = Path.Combine(_packagerFolder, "Transfer");
            if(!Directory.Exists(_transferFolder))
            {
                Directory.CreateDirectory(_transferFolder);
            }
            _packageFolder = Path.Combine(_packagerFolder, "Dist");
            if(!Directory.Exists(_packageFolder))
            {
                Directory.CreateDirectory(_packageFolder);
            }
        }

        public void StartPackage(string version)
        {
            if (CurrentTask != null)
            {
                CurrentTask.Kill();
                CurrentTask = null;
            }
            CurrentTask = new PackageTask(version, _transferFolder, _packageFolder);
        }


        public void EndPackage()
        {
            if (CurrentTask != null)
            {
                CurrentTask.Close();
                CurrentTask = null;
            }
        }

        public void KillTask()
        {
            if(CurrentTask != null)
            {
                CurrentTask.Kill();
                CurrentTask = null;
            } 
        }
    }

    class PackageManager : IPackageManager
    {
        private readonly ConcurrentDictionary<string, Packager> _packagers = new ConcurrentDictionary<string,Packager>();

        public void EndPackage(string packagerId, string taskId)
        {
            if (_packagers.TryGetValue(packagerId, out var packager))
            {
                var task = packager.CurrentTask;
                if (task == null)
                {
                    throw new InvalidOperationException("No task is running.");
                }
                if (packager.CurrentTask.Id != taskId)
                {
                    throw new InvalidOperationException("The task is not current running task.");
                }
                packager.EndPackage();
            }
            else
            {
                throw new InvalidOperationException("Packager does not exist.");
            }
        }

        public void EndTransfer(string packagerId, string taskId)
        {
            if (_packagers.TryGetValue(packagerId, out var packager))
            {
                var task = packager.CurrentTask;
                if (task == null)
                {
                    throw new InvalidOperationException("No task is running.");
                }
                if (packager.CurrentTask.Id != taskId)
                {
                    throw new InvalidOperationException("The task is not current running task.");
                }
                packager.CurrentTask.EndTransfer();
            }
            else
            {
                throw new InvalidOperationException("Packager does not exist.");
            }
        }

        public void Execute(string packagerId, string taskId, string fileName)
        {
            if (_packagers.TryGetValue(packagerId, out var packager))
            {
                var task = packager.CurrentTask;
                if (task == null)
                {
                    throw new InvalidOperationException("No task is running.");
                }
                if (packager.CurrentTask.Id != taskId)
                {
                    throw new InvalidOperationException("The task is not current running task.");
                }
                packager.CurrentTask.Execute(fileName);
            }
            else
            {
                throw new InvalidOperationException("Packager does not exist.");
            }
        }

        public string GetOrCreatePackager(string projectName)
        {
            var packager = _packagers.Values.FirstOrDefault(x => x.ProjectName == projectName);
            if(packager == null)
            {
                packager = new Packager(projectName);
                _packagers.TryAdd(packager.Id, packager);
            }
            return packager.Id;
        }

        public string GetPackageTaskState(string packagerId, string taskId)
        {
            if (_packagers.TryGetValue(packagerId, out var packager))
            {
                var task = packager.CurrentTask;
                if (task == null)
                {
                    throw new InvalidOperationException("No task is running.");
                }
                if (packager.CurrentTask.Id != taskId)
                {
                    throw new InvalidOperationException("The task is not current running task.");
                }
                return packager.CurrentTask.State.ToString();
            }
            else
            {
                throw new InvalidOperationException("Packager does not exist.");
            }
        }

        public void KillPackager(string packagerId)
        {
            if (_packagers.TryGetValue(packagerId, out var packager))
            {
                packager.KillTask();
                _packagers.TryRemove(packager.ProjectName, out _);
            }
            else
            {
                throw new InvalidOperationException("Packager does not exist.");
            }
        }

        public void KillPackageTask(string packagerId, string taskId)
        {
            if (_packagers.TryGetValue(packagerId, out var packager))
            {
                var task = packager.CurrentTask;
                if (task == null)
                {
                    throw new InvalidOperationException("No task is running.");
                }
                if (packager.CurrentTask.Id != taskId)
                {
                    throw new InvalidOperationException("The task is not current running task.");
                }
                packager.KillTask();

            }
            else
            {
                throw new InvalidOperationException("Packager does not exist.");
            }
        }

        public string StartPackageTask(string packagerId, string version)
        {
            if(_packagers.TryGetValue(packagerId, out var packager))
            {
                packager.StartPackage(version);
                return packager.CurrentTask.Id;
            }
            else
            {
                throw new InvalidOperationException("Packager does not exist.");
            }
        }

        public void StartTransfer(string packagerId, string taskId, uint hashCode)
        {
            if (_packagers.TryGetValue(packagerId, out var packager))
            {
                var task = packager.CurrentTask;
                if(task == null)
                {
                    throw new InvalidOperationException("No task is running.");
                }
                if(packager.CurrentTask.Id != taskId)
                {
                    throw new InvalidOperationException("The task is not current running task.");
                }
                packager.CurrentTask.StartTransfer(hashCode);
            }
            else
            {
                throw new InvalidOperationException("Packager does not exist.");
            }
        }

        public void TransferData(string packagerId, string taskId, byte[] data)
        {
            if (_packagers.TryGetValue(packagerId, out var packager))
            {
                var task = packager.CurrentTask;
                if (task == null)
                {
                    throw new InvalidOperationException("No task is running.");
                }
                if (packager.CurrentTask.Id != taskId)
                {
                    throw new InvalidOperationException("The task is not current running task.");
                }
                packager.CurrentTask.AddTransferData(data);
            }
            else
            {
                throw new InvalidOperationException("Packager does not exist.");
            }
        }
    }
}