Esempio n. 1
0
        private static void SetParams()
        {
            var prop = AppPropertiesSingle.GetInstance();

            prop.SetBufferSize(1048576);

            prop.SetProcessorCount(Environment.ProcessorCount);
        }
        private static CommamdsEnum GetParams(string[] args)
        {
            var  app       = AppPropertiesSingle.GetInstance();
            var  parseArgs = new ParsingInputParameters(args, app.ParamsDictionary);
            bool rez       = parseArgs.Parse();

            if (!rez)
            {
                Console.WriteLine("Ошибка ввода параметров запуска Архиватора!");
                return(CommamdsEnum.Help);
            }

            app.SetInFilePath(parseArgs.InFilePath);
            app.SetOutFilePath(parseArgs.OutFilePath);
            return(parseArgs.ChosenCommand);
        }
Esempio n. 3
0
        private static void CleanTemp(bool deleteTempDir = true)
        {
            var app = AppPropertiesSingle.GetInstance();

            if (!Directory.Exists(app.TempPath))
            {
                return;
            }

            var files = Directory.GetFiles(app.TempPath);

            foreach (var file in files)
            {
                File.Delete(file);
            }

            if (!deleteTempDir)
            {
                return;
            }


            try
            {
                DeleteTempDir(app.TempPath);
            }
            catch (IOException)
            {
                Thread.Sleep(1000);
                try
                {
                    DeleteTempDir(app.TempPath);
                }
                catch (IOException)
                {
                    //
                }
            }
        }
        public void Choose()
        {
            var appProp = AppPropertiesSingle.GetInstance();

            if (appProp.IsBigFile)
            {
                Collecting = new BringTogetherMulty();
            }
            else
            {
                Collecting = new BringTogether();
            }

            switch (m_Command)
            {
            case CommamdsEnum.Compress:
                if (appProp.IsBigFile)
                {
                    CutFile = new CutInPiecesNormal();
                }
                else
                {
                    CutFile = new CutInPiecesNormalOneThread();
                }
                break;

            case CommamdsEnum.Decompress:
                if (appProp.IsBigFile)
                {
                    CutFile = new CutInPiecesCompressed();
                }
                else
                {
                    CutFile = new CutInPiecesCompressedOneThread();
                }
                break;
            }
        }
Esempio n. 5
0
        /// <summary>
        /// файл существует?
        /// если decompress это точно GZ?
        /// файл большой?
        /// </summary>
        /// <returns></returns>
        private bool CheckInFile()
        {
            var app = AppPropertiesSingle.GetInstance();

            if (!File.Exists(app.InFilePath))
            {
                ErrMsg = "входящий файл не существует";
                return(false);
            }

            if (m_Command == CommamdsEnum.Decompress)
            {
                // проверка что это точно GZ
                using (var reader = new BinaryReader(new FileStream(app.InFilePath, FileMode.Open, FileAccess.Read)))
                {
                    var bytes = reader.ReadBytes(10);
                    if (bytes[0] != 31 || bytes[1] != 139)
                    {
                        ErrMsg = "входящий файл не является архивом Gzip";
                        return(false);
                    }
                }

                Console.WriteLine("Вычисляем размер разархивированного файла...");
                // получить общий размер распакованного файла
                m_DecompressedFileLen = 0;
                using (var reader = new FileStream(app.InFilePath, FileMode.Open, FileAccess.Read))
                {
                    while (reader.Position < reader.Length)
                    {
                        var buffer = new byte[8];
                        reader.Read(buffer, 0, 8);
                        var compressedBlockLength = BitConverter.ToInt32(buffer, 4);
                        var comressedBytes        = new byte[compressedBlockLength + 1];
                        buffer.CopyTo(comressedBytes, 0);
                        reader.Read(comressedBytes, 8, compressedBlockLength - 8);
                        var blockSize = BitConverter.ToInt32(comressedBytes, compressedBlockLength - 4);
                        m_DecompressedFileLen += blockSize;
                    }
                }
            }

            // берем свободную оперативную память
            var freeMemory = FreeRamMemory.GetFreeRamMemoryMb();

            // если две длины файла больше чем (свободная оперативка - 10%) - тогда юзаем алгоритм больших файлов
            long fileLen;

            if (m_Command == CommamdsEnum.Decompress)
            {
                //если это разархивация - тогда смотрим по длине разархивированного файла
                fileLen = m_DecompressedFileLen + m_DecompressedFileLen / 10;
            }
            else
            {
                // если это архивация - берем только входящий файл
                var fileInfo = new FileInfo(app.InFilePath);
                fileLen = fileInfo.Length;
            }

            // в Мб
            fileLen = fileLen / 1024 / 1024;

            if (fileLen * 2 > freeMemory || fileLen > 1000)
            {
                app.SetBigFile();
                Console.WriteLine("Ух ты, большой файлик, придется повозиться с диском ;)");
            }

            return(true);
        }
Esempio n. 6
0
        private bool CheckOutFile()
        {
            var app = AppPropertiesSingle.GetInstance();

            if (File.Exists(app.OutFilePath))
            {
                ErrMsg = "такой выходной файл уже есть";
                return(false);
            }

            // можно создать файл по директории?
            try
            {
                using (File.Create(app.OutFilePath)) { }
                File.Delete(app.OutFilePath);
            }
            catch
            {
                ErrMsg = "не могу создать выходной файл, проверьте доступ";
                return(false);
            }

            // если входящий файл большой - определим временный путь для частей
            var outDir = Path.GetDirectoryName(app.OutFilePath);

            if (string.IsNullOrEmpty(outDir))
            {
                ErrMsg = "не могу прочитать директорию до файла";
                return(false);
            }

            if (app.IsBigFile)
            {
                var temp = Path.Combine(outDir, "GZip");
                try
                {
                    Directory.CreateDirectory(temp);
                }
                catch (Exception)
                {
                    ErrMsg = "не могу создать временный путь: возможно к диску нет доступа " + temp;
                }
                app.SetTempPath(temp);
            }


            // определим хватит ли места для создания файла
            if (!Path.IsPathRooted(app.OutFilePath))
            {
                ErrMsg = "необходимо указать полный путь для выходного файла";
                return(false);
            }
            string disk      = Path.GetPathRoot(app.OutFilePath);
            long   freeSpace = GetTotalFreeSpace(disk);

            if (freeSpace < 0)
            {
                ErrMsg = "не могу прочитать свободное место на диске " + disk;
                return(false);
            }

            long fileLen;

            if (m_Command == CommamdsEnum.Decompress)
            {
                fileLen = m_DecompressedFileLen;
            }
            else
            {
                var info = new FileInfo(app.InFilePath);
                fileLen = info.Length;
            }

            //добавим 5% на всякий
            fileLen += fileLen / 20;

            if (fileLen > freeSpace)
            {
                ErrMsg = "недостаточно свободного места на диске " + disk;
                return(false);
            }

            return(true);
        }
Esempio n. 7
0
        static void Main(string[] args)
        {
            // Установим основные параметры архиватора
            SetParams();

            // поговорим с юзером, чтобы узнать что он хочет, если это нужно (уже есть входящие параметры)
            var command = DialogWithUser.GoDialog(args);

            if (command == CommamdsEnum.Exit)
            {
                Console.WriteLine("До свидания! Приходите ещё!");
                return;
            }

            Console.WriteLine("Проверка входящих параметров...");
            var check = new CheckFiles(command);

            if (!check.Check())
            {
                Console.WriteLine("Ошибка проверки входных параметров: {0}", check.ErrMsg);
                return;
            }

            // таймер процесса
            var sw = new Stopwatch();

            sw.Start();

            // выбор стратегии в зависимости от команды
            var cs = new ChooseStrategy(command);

            cs.Choose();
            var fassade = new LogicFassade(cs.CutFile, cs.Collecting);

            // сообщения о прогрессе
            cs.CutFile.NotifyProgress    += NotifyProgress;
            cs.Collecting.NotifyProgress += NotifyProgress;

            var appProp = AppPropertiesSingle.GetInstance();

            Console.WriteLine("Работаю с файлом {0}", appProp.InFilePath);
            switch (command)
            {
            case CommamdsEnum.Compress:
                Console.WriteLine("Разрежем файл на кусочки, архивация кусочков...");
                break;

            case CommamdsEnum.Decompress:
                Console.WriteLine("Разрежем файл на кусочки, разархивация кусочков...");
                break;

            default:
                Console.WriteLine("Идет какойто непонятный процесс...");
                break;
            }
            CleanTemp(false);
            fassade.CutInPieces();
            NotificTime(sw.Elapsed);
            GC.Collect();

            // собрать файл
            Console.WriteLine("Собираем файл после процесса...");
            fassade.BringUpFile();
            Console.Write("\r");

            Console.WriteLine("Процесс успешно завершен. Диагностика выполнения:");
            sw.Stop();
            NotificTime(sw.Elapsed);
            Console.WriteLine("Убираю за собой....");
            CleanTemp();
            Console.WriteLine("Готово! Выходной файл {0}", appProp.OutFilePath);
            Console.ReadKey();
        }