SimpleVirtualDrive/SvdCli/CliProgram.cs

using SvdCli.App;
using SvdCli.ServiceUtils;
using SvdCli.Storage;
using SvdCli.WindowsService;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Security;
using System.ServiceProcess;
using System.Text.RegularExpressions;

namespace SvdCli
{
    internal static class CliProgram
    {
        private static void Main(string[] args)
        {
            if (args.Length < 3)
            {
                Console.WriteLine(@"Usage:");
                Console.WriteLine(@"");
                Console.WriteLine(@"Create Raw 50GB C:\Path\To\Your\Image.img");
                Console.WriteLine(@"Create Bdd 10GB 64KB C:\Path\To\Your\Bdd.bdd");
                Console.WriteLine(@"Create Bdd 64KB C:\Path\To\Your\Image.img C:\Path\To\Your\Bdd.bdd");
                Console.WriteLine(@"Compact Bdd C:\Path\To\Your\Bdd.bdd");
                Console.WriteLine(@"");
                Console.WriteLine(@"[Install ServiceName|Service] <Mount|Server 0.0.0.0 2333> RamDisk 10GB");
                Console.WriteLine(@"[Install ServiceName|Service] <Mount|Server 0.0.0.0 2333> RamDisk 10GB C:\Path\To\Your\Bdd.Bdd [ReadOnly]");
                Console.WriteLine(@"[Install ServiceName|Service] <Mount|Server 0.0.0.0 2333> Image C:\Path\To\Your\Image.img [ReadOnly]");
                Console.WriteLine(@"[Install ServiceName|Service] <Mount|Server 0.0.0.0 2333> Image C:\Path\To\Your\Bdd.bdd [ReadOnly]");
                Console.WriteLine(@"[Install ServiceName|Service] Mount Net 192.168.233.233 2333");
                Console.WriteLine(@"[Install ServiceName|Service] Server 192.168.233.233 2333 Dispatch 64KB C:\Path\To\Your\Image.img C:\Path\To\Your\Dir\");
                Console.WriteLine(@"");
                Console.WriteLine(@"Uninstall ServiceName           Safe:Restrict to register by this program");
                Console.WriteLine(@"");
                Console.Write("Press ENTER to exit");
                Console.ReadLine();
                return;
            }

            EndPoint serverEndPoint = null;
            IStorage storage = null;
            switch (args[0].ToLower())
            {
                case "install":
                    {
                        var serviceName = args[1];
                        var serviceArgs = new List<string>() { Assembly.GetExecutingAssembly().Location, "Service" };
                        serviceArgs.AddRange(args.Skip(2));
                        ServiceHelper.Install(serviceName, "", string.Join(" ", serviceArgs), "", ServiceStartType.Auto);
                    }
                    break;

                case "uninstall":
                    {
                        var serviceName = args[1];
                        var binPath = ServiceHelper.GetBinPath(serviceName);

                        if (true == binPath?.Contains(Path.GetFileName(Assembly.GetExecutingAssembly().Location))) ServiceHelper.Uninstall(serviceName);
                        else throw new SecurityException("Specified service must register by this program");
                    }
                    break;

                case "service":
                    args = args.Skip(1).ToArray();

                    switch (args[0].ToLower())
                    {
                        default: throw new InvalidOperationException("Invalid param: OP");
                        case "server":
                            serverEndPoint = new IPEndPoint(IPAddress.Parse(args[1]), int.Parse(args[2]));
                            if (args[3].ToLower() == "dispatch")
                            {
                                //Start TCP Server and listening
                                //Accept and Get Client MAC
                                //Create Bdd If Not Exist
                                //Serving Bdd in `forked' Process use Socket.DuplicateAndClose
                                throw new NotImplementedException();
                            }
                            args = args.Skip(3).ToArray();
                            goto case "mount";
                        case "mount":
                            storage = ParseMount(args.Skip(1).ToArray());
                            break;
                    }

                    ServiceBase.Run(new ServiceBase[] { new SvdServiceForWindows(new SvdService(storage, serverEndPoint)) });
                    break;

                default:
                    switch (args[0].ToLower())
                    {
                        case "create":
                            ParseCreate(args.Skip(1).ToArray());
                            return;

                        case "compact":
                            ParseCompact(args.Skip(1).ToArray());
                            return;

                        case "server":
                            serverEndPoint = new IPEndPoint(IPAddress.Parse(args[1]), int.Parse(args[2]));
                            args = args.Skip(3).ToArray();

                            goto case "mount";
                        case "mount":
                            storage = ParseMount(args.Skip(1).ToArray());
                            break;
                    }

                    var svc = new SvdService(storage, serverEndPoint);
                    svc.Start();
                    Console.WriteLine();
                    Console.Write("Press ENTER to Stop");
                    Console.ReadLine();
                    svc.Stop();
                    break;
            }
        }

        private static void ParseCreate(string[] args)
        {
            //Raw 50GB C:\Path\To\Your\Image.img
            //Bdd 10GB 64KB C:\Path\To\Your\Bdd.bdd
            //Bdd 64KB C:\Path\To\Your\Image.img C:\Path\To\Your\Bdd.bdd

            switch (args[0].ToLower())
            {
                case "raw":
                case "bdd":
                default: throw new ArgumentException("Unknown image type");
            }
        }

        private static IStorage ParseMount(string[] args)
        {
            //RamDisk 10GB
            //RamDisk 10GB C:\Path\To\Your\Bdd.Bdd [ReadOnly]
            //Image C:\Path\To\Your\Image.img [ReadOnly]
            //Image C:\Path\To\Your\Bdd.bdd [ReadOnly]
            //Net 192.168.233.233 2333

            switch (args[0].ToLower())
            {
                case "ramdisk":

                    if (ParseDiskSize(args[1], out var value, out var unit))
                    {
                        if (false == string.IsNullOrWhiteSpace(unit) && false == unit.StartsWith("g"))
                            throw new ArgumentException("RamDisk only GB supported");
                        var storage = new UnmanagedGigabyteRamDisk(value);

                        //TODO: load bdd
                        if (args.Length > 2) throw new NotImplementedException();

                        if (args.Length > 3 && args[3].ToLower() == "readonly") storage.WriteProtect = true;

                        return storage;
                    }

                    throw new ArgumentException("Failure to parse args");

                case "image":
                case "net":
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }

        private static void ParseCompact(string[] args)
        {
            //Bdd C:\Path\To\Your\Bdd.bdd
            throw new NotImplementedException();
        }

        //////////////////////////////////////////////

        private static readonly Regex DiskSizeRegex = new Regex(@"^(\d+)([KkMmGg]{1}[Bb]{0,1}){0,1}$", RegexOptions.Compiled);

        private static bool ParseDiskSize(string input, out int value, out string unit)
        {
            var m = DiskSizeRegex.Match(input);
            if (false == m.Success)
            {
                value = 0;
                unit = null;
                return false;
            }

            unit = m.Groups[2].Value.ToLower();
            value = int.Parse(m.Groups[1].Value);
            return true;
        }

        private static long CalcDiskSize(int value, string unit)
        {
            switch (unit.ToLower())
            {
                case "":
                    return value;

                case "k":
                case "kb":
                    return value * CapacityUnits.KiloByte;

                case "m":
                case "mb":
                    return value * CapacityUnits.MegaByte;

                case "g":
                case "gb":
                    return value * CapacityUnits.Gigabyte;

                default: throw new ArgumentOutOfRangeException();
            }
        }
    }
}