Esempio n. 1
0
        public void Dispose()
        {
            var exts = new [] { ".md", ".exe" };

            Utils.DeleteDirectory(Path.Combine(WorkingDirectory, ID));
            Profiles.Do(p =>
            {
                foreach (var ext in exts)
                {
                    var path = Path.Combine(Directory.GetCurrentDirectory(), p + ext);
                    if (File.Exists(path))
                    {
                        File.Delete(path);
                    }
                }
            });
        }
Esempio n. 2
0
        public void Write()
        {
            var mainStream = File.Open(_path, FileMode.Create, FileAccess.Write);

            _streams.Add(mainStream);

            switch (Version)
            {
            case PackageVersion.V16:
            {
                WriteV16(mainStream);
                break;
            }

            case PackageVersion.V15:
            {
                WriteV15(mainStream);
                break;
            }

            case PackageVersion.V13:
            {
                WriteV13(mainStream);
                break;
            }

            case PackageVersion.V10:
            {
                WriteV10(mainStream);
                break;
            }

            case PackageVersion.V9:
            case PackageVersion.V7:
            {
                WriteV7(mainStream);
                break;
            }

            default:
            {
                throw new ArgumentException($"Cannot write version {Version} packages");
            }
            }
        }
Esempio n. 3
0
        public static void GenerateMerges(Installer installer)
        {
            installer.ModList
            .Directives
            .OfType <MergedPatch>()
            .PMap(m =>
            {
                Utils.LogStatus($"Generating zEdit merge: {m.To}");

                var src_data = m.Sources.Select(s => File.ReadAllBytes(Path.Combine(installer.Outputfolder, s.RelativePath)))
                               .ConcatArrays();

                var patch_data = installer.LoadBytesFromPath(m.PatchID);

                using (var fs = File.OpenWrite(Path.Combine(installer.Outputfolder, m.To)))
                    BSDiff.Apply(new MemoryStream(src_data), () => new MemoryStream(patch_data), fs);
            });
        }
Esempio n. 4
0
        private void ForcePortable()
        {
            var path = Path.Combine(OutputFolder, "portable.txt");

            if (File.Exists(path))
            {
                return;
            }

            try
            {
                File.WriteAllText(path, "Created by Wabbajack");
            }
            catch (Exception e)
            {
                Utils.Error(e, $"Could not create portable.txt in {OutputFolder}");
            }
        }
Esempio n. 5
0
        private void WriteRemappedFile(RemappedInlineFile directive)
        {
            var data = Encoding.UTF8.GetString(LoadBytesFromPath(directive.SourceDataID));

            data = data.Replace(Consts.GAME_PATH_MAGIC_BACK, GameFolder);
            data = data.Replace(Consts.GAME_PATH_MAGIC_DOUBLE_BACK, GameFolder.Replace("\\", "\\\\"));
            data = data.Replace(Consts.GAME_PATH_MAGIC_FORWARD, GameFolder.Replace("\\", "/"));

            data = data.Replace(Consts.MO2_PATH_MAGIC_BACK, OutputFolder);
            data = data.Replace(Consts.MO2_PATH_MAGIC_DOUBLE_BACK, OutputFolder.Replace("\\", "\\\\"));
            data = data.Replace(Consts.MO2_PATH_MAGIC_FORWARD, OutputFolder.Replace("\\", "/"));

            data = data.Replace(Consts.DOWNLOAD_PATH_MAGIC_BACK, DownloadFolder);
            data = data.Replace(Consts.DOWNLOAD_PATH_MAGIC_DOUBLE_BACK, DownloadFolder.Replace("\\", "\\\\"));
            data = data.Replace(Consts.DOWNLOAD_PATH_MAGIC_FORWARD, DownloadFolder.Replace("\\", "/"));

            File.WriteAllText(Path.Combine(OutputFolder, directive.To), data);
        }
Esempio n. 6
0
        public void File_ReadAllText()
        {
            Console.WriteLine("File.ReadAllText()\n");

            // Create file and append text.
            var tempFile = Path.GetTempFileName();

            string[] createText = { "Hello", "And", "Welcome" };
            File.WriteAllLines(tempFile, createText);

            // Open the file to read from.
            var textRead = File.ReadAllText(tempFile);

            Console.WriteLine(textRead);

            File.Delete(tempFile, true);
            Assert.IsFalse(File.Exists(tempFile), "Cleanup failed: File should have been removed.");
        }
Esempio n. 7
0
        public void File_WriteAllText()
        {
            Console.WriteLine("File.WriteAllText()");
            Console.WriteLine("\n\tDefault AlphaFS Encoding: [{0}]", NativeMethods.DefaultFileEncoding.EncodingName);

            // Create file and append text.
            var tempFile = Path.GetTempFileName();

            var allLines = UnitTestConstants.TextHelloWorld;

            // Create real UTF-8 file.
            File.WriteAllText(tempFile, allLines, NativeMethods.DefaultFileEncoding);

            // Read filestream contents.
            using (var streamRead = File.OpenText(tempFile))
            {
                var line = streamRead.ReadToEnd();

                Console.WriteLine("\n\tCreated: [{0}] filestream: [{1}]\n\n\tWriteAllText content:\n{2}", streamRead.CurrentEncoding.EncodingName, tempFile, line);

                Assert.IsTrue(line.Contains(allLines));
            }

            // (over)Write.
            File.WriteAllText(tempFile, "Append 1");
            File.WriteAllText(tempFile, allLines);
            File.WriteAllText(tempFile, "Append 2");
            File.WriteAllText(tempFile, allLines);

            // Read filestream contents.
            using (var streamRead = File.OpenText(tempFile))
            {
                var line = streamRead.ReadToEnd();

                Console.WriteLine("\tWriteAllText content:\n{0}", line);

                Assert.IsTrue(line.Contains(allLines));
                Assert.IsTrue(!line.Contains("Append 1"));
                Assert.IsTrue(!line.Contains("Append 2"));
            }

            File.Delete(tempFile, true);
            Assert.IsFalse(File.Exists(tempFile), "Cleanup failed: File should have been removed.");
        }
Esempio n. 8
0
    private static void ProcessFile(string file, bool q, string dt)
    {
        try
        {
            var raw = File.ReadAllBytes(file);

            if (raw[0] == 1 || raw[0] == 2)
            {
                var di = new DollarI(raw, file);

                DisplayDollarI(di, dt, q);
            }
            else if (raw[0] == 5)
            {
                var info = new Info2(raw, file);

                DisplayInfo2(info, q, dt);
            }
            else
            {
                Log.Warning(
                    "Unknown header 0x{Raw:X}! Send file to {Email} so support can be added", raw[0], "*****@*****.**");
                _failedFiles.Add(file);
            }

            if (q == false)
            {
                Console.WriteLine();
            }
        }
        catch (UnauthorizedAccessException ua)
        {
            Log.Error(ua,
                      "Unable to access {File}. Are you running as an administrator? Error: {Message}", file, ua.Message);
            _failedFiles.Add(file);
        }
        catch (Exception ex)
        {
            _failedFiles.Add(file);
            Log.Error(ex,
                      "Error processing file {File} Please send it to {Email}. Error: {Message}", file, "*****@*****.**", ex.Message);
        }
    }
Esempio n. 9
0
        private static void ProcessFile(string file)
        {
            try
            {
                var raw = File.ReadAllBytes(file);

                if (raw[0] == 1 || raw[0] == 2)
                {
                    var di = new DollarI(raw, file);

                    DisplayDollarI(di);
                }
                else if (raw[0] == 5)
                {
                    var info = new Info2(raw, file);

                    DisplayInfo2(info);
                }
                else
                {
                    _logger.Warn(
                        $"Unknown header '0x{raw[0]:X}! Send file to [email protected] so support can be added");
                    _failedFiles.Add(file);
                }

                if (_fluentCommandLineParser.Object.Quiet == false)
                {
                    _logger.Info("");
                }
            }
            catch (UnauthorizedAccessException ua)
            {
                _logger.Error(
                    $"Unable to access '{_fluentCommandLineParser.Object.File}'. Are you running as an administrator? Error: {ua.Message}");
                _failedFiles.Add(file);
            }
            catch (Exception ex)
            {
                _failedFiles.Add(file);
                _logger.Error(
                    $"Error processing file '{_fluentCommandLineParser.Object.File}' Please send it to [email protected]. Error: {ex.Message}");
            }
        }
Esempio n. 10
0
        public void Configure()
        {
            File.WriteAllLines(Path.Combine(MO2Folder, "ModOrganizer.ini"), new []
            {
                "[General]",
                $"gameName={Game.MetaData().MO2Name}",
                $"gamePath={GameFolder.Replace("\\", "\\\\")}",
                $"download_directory={DownloadsFolder}"
            });

            Directory.CreateDirectory(DownloadsFolder);
            Directory.CreateDirectory(Path.Combine(GameFolder, "Data"));

            Profiles.Do(profile =>
            {
                File.WriteAllLines(Path.Combine(MO2Folder, "profiles", profile, "modlist.txt"),
                                   Mods.Select(s => $"+{s}").ToArray());
            });
        }
Esempio n. 11
0
        public static void Rotate(string filenameBase)
        {
            if (File.Exists(filenameBase))
            {
                for (int i = 8; i >= 0; i--)
                {
                    string fn = filenameBase + "." + i;
                    if (File.Exists(fn))
                    {
                        string fn2 = filenameBase + "." + (i + 1);
                        if (File.Exists(fn2))
                        {
                            File.Delete(fn2);
                        }
                        File.Move(fn, fn2);
                    }
                }

                File.Copy(filenameBase, filenameBase + ".0");
            }
        }
Esempio n. 12
0
        internal List <string> GetArchiveEntryNames(VirtualFile file)
        {
            if (!file.IsStaged)
            {
                throw new InvalidDataException("File is not staged");
            }

            if (file.Extension == ".bsa")
            {
                using (var ar = new BSAReader(file.StagedPath))
                {
                    return(ar.Files.Select(f => f.Path).ToList());
                }
            }
            if (file.Extension == ".zip")
            {
                using (var s = new ZipFile(File.OpenRead(file.StagedPath)))
                {
                    s.IsStreamOwner = true;
                    s.UseZip64      = UseZip64.On;

                    if (s.OfType <ZipEntry>().FirstOrDefault(e => !e.CanDecompress) == null)
                    {
                        return(s.OfType <ZipEntry>()
                               .Where(f => f.IsFile)
                               .Select(f => f.Name.Replace('/', '\\'))
                               .ToList());
                    }
                }
            }

            /*
             * using (var e = new ArchiveFile(file.StagedPath))
             * {
             *  return e.Entries
             *          .Where(f => !f.IsFolder)
             *          .Select(f => f.FileName).ToList();
             * }*/
            return(null);
        }
Esempio n. 13
0
        public void SyncToDisk()
        {
            if (!_disableDiskCache)
            {
                Utils.Status("Syncing VFS Cache");
                lock (this)
                {
                    try
                    {
                        _isSyncing = true;

                        if (File.Exists("vfs_cache.bin_new"))
                        {
                            File.Delete("vfs_cache.bin_new");
                        }

                        using (var fs = File.OpenWrite("vfs_cache.bin_new"))
                            using (var bw = new BinaryWriter(fs))
                            {
                                Utils.Log($"Syncing VFS to Disk: {_files.Count} entries");
                                foreach (var f in _files.Values)
                                {
                                    f.Write(bw);
                                }
                            }

                        if (File.Exists("vfs_cache.bin"))
                        {
                            File.Delete("vfs_cache.bin");
                        }

                        File.Move("vfs_cache.bin_new", "vfs_cache.bin");
                    }
                    finally
                    {
                        _isSyncing = false;
                    }
                }
            }
        }
Esempio n. 14
0
        public Package Read()
        {
            var mainStream = File.Open(_path, FileMode.Open, FileAccess.Read, FileShare.Read);

            using (var reader = new BinaryReader(mainStream, new UTF8Encoding(), true))
            {
                // Check for v13 package headers
                mainStream.Seek(-8, SeekOrigin.End);
                Int32  headerSize = reader.ReadInt32();
                byte[] signature  = reader.ReadBytes(4);
                if (Package.Signature.SequenceEqual(signature))
                {
                    mainStream.Seek(-headerSize, SeekOrigin.End);
                    return(ReadPackageV13(mainStream, reader));
                }

                // Check for v10 package headers
                mainStream.Seek(0, SeekOrigin.Begin);
                signature = reader.ReadBytes(4);
                Int32 version;
                if (Package.Signature.SequenceEqual(signature))
                {
                    version = reader.ReadInt32();
                    if (version == 10)
                    {
                        return(ReadPackageV10(mainStream, reader));
                    }
                }

                // Check for v9 and v7 package headers
                mainStream.Seek(0, SeekOrigin.Begin);
                version = reader.ReadInt32();
                if (version == 7 || version == 9)
                {
                    return(ReadPackageV7(mainStream, reader));
                }

                throw new NotAPackageException("No valid signature found in package file");
            }
        }
Esempio n. 15
0
        public void VerifyAllFiles()
        {
            foreach (var dest_file in Directory.EnumerateFiles(InstallFolder, "*", DirectoryEnumerationOptions.Recursive))
            {
                var rel_file = dest_file.RelativeTo(InstallFolder);
                if (rel_file.StartsWith(Consts.LOOTFolderFilesDir) || rel_file.StartsWith(Consts.GameFolderFilesDir))
                {
                    continue;
                }
                Assert.IsTrue(File.Exists(Path.Combine(MO2Folder, rel_file)), $"Only in Destination: {rel_file}");
            }

            var skip_extensions = new HashSet <string> {
                ".txt", ".ini"
            };

            foreach (var src_file in Directory.EnumerateFiles(MO2Folder, "*", DirectoryEnumerationOptions.Recursive))
            {
                var rel_file = src_file.RelativeTo(MO2Folder);

                if (rel_file.StartsWith("downloads\\"))
                {
                    continue;
                }

                var dest_file = Path.Combine(InstallFolder, rel_file);
                Assert.IsTrue(File.Exists(dest_file), $"Only in Source: {rel_file}");

                var fi_src  = new FileInfo(src_file);
                var fi_dest = new FileInfo(dest_file);



                if (!skip_extensions.Contains(Path.GetExtension(src_file)))
                {
                    Assert.AreEqual(fi_src.Length, fi_dest.Length, $"Differing sizes {rel_file}");
                    Assert.AreEqual(src_file.FileHash(), dest_file.FileHash(), $"Differing content hash {rel_file}");
                }
            }
        }
Esempio n. 16
0
        public async Task MegaDownload()
        {
            var ini = @"[General]
                        directURL=https://mega.nz/#!CsMSFaaJ!-uziC4mbJPRy2e4pPk8Gjb3oDT_38Be9fzZ6Ld4NL-k";

            var state = (AbstractDownloadState)await DownloadDispatcher.ResolveArchive(ini.LoadIniString());

            Assert.IsNotNull(state);

            var url_state = DownloadDispatcher.ResolveArchive(
                "https://mega.nz/#!CsMSFaaJ!-uziC4mbJPRy2e4pPk8Gjb3oDT_38Be9fzZ6Ld4NL-k");

            Assert.AreEqual("https://mega.nz/#!CsMSFaaJ!-uziC4mbJPRy2e4pPk8Gjb3oDT_38Be9fzZ6Ld4NL-k",
                            ((MegaDownloader.State)url_state).Url);


            var converted = await state.RoundTripState();

            Assert.IsTrue(await converted.Verify(new Archive {
                Size = 20
            }));
            var filename = Guid.NewGuid().ToString();

            Assert.IsTrue(converted.IsWhitelisted(new ServerWhitelist {
                AllowedPrefixes = new List <string> {
                    "https://mega.nz/#!CsMSFaaJ!-uziC4mbJPRy2e4pPk8Gjb3oDT_38Be9fzZ6Ld4NL-k"
                }
            }));
            Assert.IsFalse(converted.IsWhitelisted(new ServerWhitelist {
                AllowedPrefixes = new List <string> {
                    "blerg"
                }
            }));

            await converted.Download(new Archive { Name = "MEGA Test.txt" }, filename);

            Assert.AreEqual("eSIyd+KOG3s=", Utils.FileHash(filename));

            Assert.AreEqual(File.ReadAllText(filename), "Cheese for Everyone!");
        }
Esempio n. 17
0
        // 导出数据
        private void ExportData(object sender, RoutedEventArgs e)
        {
            if (!File.Exists("./data.db"))
            {
                MessageWindow.ShowDialog("文件 data.db 不存在", this);
                return;
            }

            SaveFileDialog dlg = new SaveFileDialog
            {
                Title      = "另存为",
                FileName   = "data.db",
                DefaultExt = ".db",
                Filter     = "Data base file|*.db"
            };

            if (dlg.ShowDialog() == true)
            {
                FileInfo fi = new FileInfo("./data.db");
                fi.CopyTo(dlg.FileName);
            }
        }
Esempio n. 18
0
        public async Task DropboxTests()
        {
            var ini = @"[General]
                        directURL=https://www.dropbox.com/s/5hov3m2pboppoc2/WABBAJACK_TEST_FILE.txt?dl=0";

            var state = (AbstractDownloadState)await DownloadDispatcher.ResolveArchive(ini.LoadIniString());

            Assert.IsNotNull(state);

            var url_state = DownloadDispatcher.ResolveArchive(
                "https://www.dropbox.com/s/5hov3m2pboppoc2/WABBAJACK_TEST_FILE.txt?dl=0");

            Assert.AreEqual("https://www.dropbox.com/s/5hov3m2pboppoc2/WABBAJACK_TEST_FILE.txt?dl=1",
                            ((HTTPDownloader.State)url_state).Url);

            var converted = await state.RoundTripState();

            Assert.IsTrue(await converted.Verify(new Archive {
                Size = 20
            }));
            var filename = Guid.NewGuid().ToString();

            Assert.IsTrue(converted.IsWhitelisted(new ServerWhitelist {
                AllowedPrefixes = new List <string> {
                    "https://www.dropbox.com/s/5hov3m2pboppoc2/WABBAJACK_TEST_FILE.txt?"
                }
            }));
            Assert.IsFalse(converted.IsWhitelisted(new ServerWhitelist {
                AllowedPrefixes = new List <string> {
                    "blerg"
                }
            }));

            await converted.Download(new Archive { Name = "MEGA Test.txt" }, filename);

            Assert.AreEqual("eSIyd+KOG3s=", Utils.FileHash(filename));

            Assert.AreEqual(File.ReadAllText(filename), "Cheese for Everyone!");
        }
Esempio n. 19
0
        public void GetFilesWithExtension_FileContainingPatternUseToReturn()
        {
            const string name1 = "G-SN750B_02_S13UJ1NQ221583.cde";
            const string name2 = "G-SN750B_02_S13UJ1NQ221583.cde-backup-with-hash";
            var          f1    = File.Create(name1);
            var          f2    = File.Create(name2);

            f1.Close();
            f2.Close();
            var files = AlphaFSHelper.GetFilesWithExtension(".", "cde");

            foreach (var file in files)
            {
                Console.WriteLine($"file {file}");
            }

            //System.Threading.Thread.Sleep(1000); // delay 1 second

            File.Delete(name1);
            File.Delete(name2);

            Assert.That(files.Count(), Is.EqualTo(1), "Oops somehow we got a file not ending in \"cde\" in our result set.");
        }
Esempio n. 20
0
        private static void SetupNLog()
        {
            if (File.Exists(Path.Combine(BaseDirectory, "Nlog.config")))
            {
                return;
            }
            var config   = new LoggingConfiguration();
            var loglevel = LogLevel.Info;

            var layout = @"${message}";

            var consoleTarget = new ColoredConsoleTarget();

            config.AddTarget("console", consoleTarget);

            consoleTarget.Layout = layout;

            var rule1 = new LoggingRule("*", loglevel, consoleTarget);

            config.LoggingRules.Add(rule1);

            LogManager.Configuration = config;
        }
Esempio n. 21
0
        public void VerifyInstalledGameFile(string file)
        {
            var src = Path.Combine(GameFolder, file);

            Assert.IsTrue(File.Exists(src), src);

            var dest = Path.Combine(InstallFolder, Consts.GameFolderFilesDir, file);

            Assert.IsTrue(File.Exists(dest), dest);

            var src_data  = File.ReadAllBytes(src);
            var dest_data = File.ReadAllBytes(dest);

            Assert.AreEqual(src_data.Length, dest_data.Length);

            for (int x = 0; x < src_data.Length; x++)
            {
                if (src_data[x] != dest_data[x])
                {
                    Assert.Fail($"Index {x} of {Consts.GameFolderFilesDir}\\{file} are not the same");
                }
            }
        }
Esempio n. 22
0
        private static void DeleteDirectory(string path)
        {
            Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories)
            .DoProgress("Cleaning VFS Files", file =>
            {
                try
                {
                    var fi         = new FileInfo(file);
                    fi.Attributes &= ~FileAttributes.ReadOnly;
                    File.Delete(file);
                }
                catch (Exception ex)
                {
                    Utils.Log(ex.ToString());
                }
            });

            Directory.EnumerateDirectories(path, DirectoryEnumerationOptions.Recursive)
            .OrderByDescending(d => d.Length)
            .DoProgress("Cleaning VFS Folders", folder =>
            {
                try
                {
                    if (!Directory.Exists(folder))
                    {
                        return;
                    }
                    var di         = new DirectoryInfo(folder);
                    di.Attributes &= ~FileAttributes.ReadOnly;
                    Directory.Delete(path, true);
                }
                catch (Exception ex)
                {
                    Utils.Log(ex.ToString());
                }
            });
        }
Esempio n. 23
0
        private void LoadFromDisk()
        {
            try
            {
                Utils.Log("Loading VFS Cache");
                if (!File.Exists("vfs_cache.bin"))
                {
                    return;
                }
                _files = new Dictionary <string, VirtualFile>();

                try
                {
                    using (var fs = File.OpenRead("vfs_cache.bin"))
                        using (var br = new BinaryReader(fs))
                        {
                            while (true)
                            {
                                var fr = VirtualFile.Read(br);
                                _files.Add(fr.FullPath, fr);
                            }
                        }
                }
                catch (EndOfStreamException ex)
                {
                }


                CleanDB();
            }
            catch (Exception ex)
            {
                Utils.Log($"Purging cache due to {ex}");
                File.Delete("vfs_cache.bson");
                _files.Clear();
            }
        }
Esempio n. 24
0
        public async Task GoogleDriveTests()
        {
            var ini = @"[General]
                        directURL=https://drive.google.com/file/d/1grLRTrpHxlg7VPxATTFNfq2OkU_Plvh_/view?usp=sharing";

            var state = (AbstractDownloadState)await DownloadDispatcher.ResolveArchive(ini.LoadIniString());

            Assert.IsNotNull(state);

            var url_state = DownloadDispatcher.ResolveArchive(
                "https://drive.google.com/file/d/1grLRTrpHxlg7VPxATTFNfq2OkU_Plvh_/view?usp=sharing");

            Assert.AreEqual("1grLRTrpHxlg7VPxATTFNfq2OkU_Plvh_",
                            ((GoogleDriveDownloader.State)url_state).Id);

            var converted = await state.RoundTripState();

            Assert.IsTrue(await converted.Verify(new Archive {
                Size = 20
            }));
            var filename = Guid.NewGuid().ToString();

            Assert.IsTrue(converted.IsWhitelisted(new ServerWhitelist {
                GoogleIDs = new List <string> {
                    "1grLRTrpHxlg7VPxATTFNfq2OkU_Plvh_"
                }
            }));
            Assert.IsFalse(converted.IsWhitelisted(new ServerWhitelist {
                GoogleIDs = new List <string>()
            }));

            await converted.Download(new Archive { Name = "MEGA Test.txt" }, filename);

            Assert.AreEqual("eSIyd+KOG3s=", Utils.FileHash(filename));

            Assert.AreEqual(File.ReadAllText(filename), "Cheese for Everyone!");
        }
        /// <summary>
        /// Documentation: https://developers.google.com/drive/v3/web/manage-downloads
        /// </summary>
        /// <param name="_service"></param>
        /// <param name="_fileResource"></param>
        /// <param name="_saveTo"></param>
        public static Boolean downloadFile(DriveService _service, File _fileResource, string _saveTo)
        {
            var request = _service.Files.Get(_fileResource.Id);
            var stream = new System.IO.MemoryStream();

            request.Download(stream);
            System.IO.FileStream file = new System.IO.FileStream(_saveTo, System.IO.FileMode.Create, System.IO.FileAccess.Write);
            try
            {
                stream.WriteTo(file);
            }
            catch (Exception x) { log.Error("Exception[4]: " + x.Message + " | " + x); }
            finally
            {
                file.Close();
                stream.Close();
            }
            return true;
        }
        /// <summary>
        /// Documentation: https://developers.google.com/drive/v3/reference/files/update
        /// </summary>
        /// <param name="_service"></param>
        /// <param name="_uploadFile"></param>
        /// <param name="_fileId"></param>
        /// <returns></returns>
        public static File updateFile(DriveService _service, string _uploadFile, string _fileId)
        {
            Pause();
            log.Info("Update file: " + _uploadFile);
            System.IO.FileInfo f = new System.IO.FileInfo(_uploadFile);
            File file = new File();
            fileSize = f.Length;
            string name = Alpha.Path.GetFileName(_uploadFile);
            FileName = name;

            using (var stream = new System.IO.FileStream(_uploadFile, System.IO.FileMode.Open, System.IO.FileAccess.Read))
            {
                FilesResource.UpdateMediaUpload request = _service.Files.Update(file, _fileId, stream, GetMimeType(_uploadFile));
                try
                {
                    request.ChunkSize = 1048576;
                    _ChunkSize = 1048576;

                    request.ProgressChanged += Upload_ProgressChanged;
                    request.Upload();

                    while (request.ContentStream.Position != request.ContentStream.Length)
                    {
                        Pause();
                        for (int i = 15; i > 0; i = i - 1)
                        {
                            log.Error("Network error. Resume attempt.");
                            Application.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() =>
                            {
                                ((MainWindow)Application.Current.MainWindow).lb_currUpload.Content = "Network error. Resume attempt in: " + i;
                            }));
                            Thread.Sleep(1000);
                        }

                        request.Resume();
                    }

                    return request.ResponseBody;
                }
                catch (Exception x) { log.Error("Exception[6]: " + x.Message + " | " + x); return null; }
            }
        }
Esempio n. 27
0
        public async Task GameFileSourceDownload()
        {
            // Test mode off for this test
            Consts.TestMode = false;
            await DownloadDispatcher.GetInstance <LoversLabDownloader>().Prepare();

            var ini = $@"[General]
                        gameName={Game.SkyrimSpecialEdition.MetaData().MO2ArchiveName}
                        gameFile=Data/Update.esm";

            var state = (AbstractDownloadState)await DownloadDispatcher.ResolveArchive(ini.LoadIniString());

            Assert.IsNotNull(state);

            var converted = await state.RoundTripState();

            Assert.IsTrue(await converted.Verify(new Archive {
                Size = 20
            }));
            var filename = Guid.NewGuid().ToString();

            Assert.IsTrue(converted.IsWhitelisted(new ServerWhitelist {
                AllowedPrefixes = new List <string>()
            }));

            await converted.Download(new Archive { Name = "Update.esm" }, filename);

            Assert.AreEqual("/DLG/LjdGXI=", Utils.FileHash(filename));
            CollectionAssert.AreEqual(File.ReadAllBytes(Path.Combine(Game.SkyrimSpecialEdition.MetaData().GameLocation(), "Data/Update.esm")), File.ReadAllBytes(filename));
            Consts.TestMode = true;
        }
Esempio n. 28
0
        private static void ProcessFile(string file)
        {
            if (File.Exists(file) == false)
            {
                _logger.Warn($"'{file}' does not exist! Skipping");
                return;
            }

            _logger.Warn($"\r\nProcessing '{file}'...");

            Stream fileS;

            try
            {
                fileS = new FileStream(file, FileMode.Open, FileAccess.Read);
            }
            catch (Exception)
            {
                //file is in use

                if (Helper.IsAdministrator() == false)
                {
                    _logger.Fatal("\r\nAdministrator privileges not found! Exiting!!\r\n");
                    Environment.Exit(0);
                }

                _logger.Warn($"\r\n'{file}' is in use. Rerouting...");

                var files = new List <string>();
                files.Add(file);

                var rawFiles = Helper.GetFiles(files);
                fileS = rawFiles.First().FileStream;
            }

            try
            {
                var evt = new EventLog(fileS);

                var seenRecords = 0;

                foreach (var eventRecord in evt.GetEventRecords())
                {
                    if (_includeIds.Count > 0)
                    {
                        if (_includeIds.Contains(eventRecord.EventId) == false)
                        {
                            //it is NOT in the list, so skip
                            continue;
                        }
                    }
                    else if (_excludeIds.Count > 0)
                    {
                        if (_excludeIds.Contains(eventRecord.EventId))
                        {
                            //it IS in the list, so skip
                            continue;
                        }
                    }


                    eventRecord.SourceFile = file;
                    try
                    {
                        _csvWriter?.WriteRecord(eventRecord);
                        _csvWriter?.NextRecord();

                        var xml = string.Empty;
                        if (_swXml != null)
                        {
                            xml = eventRecord.ConvertPayloadToXml();
                            _swXml.WriteLine(xml);
                        }

                        if (_swJson != null)
                        {
                            JsConfig.IncludeNullValues = true;
                            JsConfig.DateHandler       = DateHandler.ISO8601;
                            var jsOut = eventRecord.ToJson();
                            if (_fluentCommandLineParser.Object.FullJson)
                            {
                                if (xml.IsNullOrEmpty())
                                {
                                    xml = eventRecord.ConvertPayloadToXml();
                                }
                                var xd = new XmlDocument();
                                xd.LoadXml(xml);

                                jsOut = JsonConvert.SerializeXmlNode(xd);
                            }

                            _swJson.WriteLine(jsOut);
                        }

                        seenRecords += 1;
                    }
                    catch (Exception e)
                    {
                        _logger.Error($"Error processing record #{eventRecord.RecordNumber}: {e.Message}");
                    }
                }

                if (evt.ErrorRecords.Count > 0)
                {
                    _errorFiles.Add(file, evt.ErrorRecords.Count);
                }

                _fileCount += 1;

                _logger.Info("");
                _logger.Fatal("Event log details");
                _logger.Info(evt);

                _logger.Info($"Records processed: {seenRecords:N0} Errors: {evt.ErrorRecords.Count:N0}");

                if (evt.ErrorRecords.Count > 0)
                {
                    _logger.Warn("\r\nErrors");
                    foreach (var evtErrorRecord in evt.ErrorRecords)
                    {
                        _logger.Info($"Record #{evtErrorRecord.Key}: Error: {evtErrorRecord.Value}");
                    }
                }

                if (_fluentCommandLineParser.Object.Metrics && evt.EventIdMetrics.Count > 0)
                {
                    _logger.Fatal("\r\nMetrics");
                    _logger.Warn("Event Id\tCount");
                    foreach (var esEventIdMetric in evt.EventIdMetrics.OrderBy(t => t.Key))
                    {
                        if (_includeIds.Count > 0)
                        {
                            if (_includeIds.Contains((int)esEventIdMetric.Key) == false)
                            {
                                //it is NOT in the list, so skip
                                continue;
                            }
                        }
                        else if (_excludeIds.Count > 0)
                        {
                            if (_excludeIds.Contains((int)esEventIdMetric.Key))
                            {
                                //it IS in the list, so skip
                                continue;
                            }
                        }

                        _logger.Info($"{esEventIdMetric.Key}\t\t{esEventIdMetric.Value:N0}");
                    }
                }
            }
            catch (Exception e)
            {
                if (e.Message.Contains("Invalid signature! Expected 'ElfFile"))
                {
                    _logger.Info($"'{file}' is not an evtx file! Message: {e.Message} Skipping...");
                }
                else
                {
                    _logger.Error($"Error processing '{file}'! Message: {e.Message}");
                }
            }

            fileS?.Close();
        }
Esempio n. 29
0
        public void SetVolumeMountPoint()
        {
            Console.WriteLine("Volume.SetVolumeMountPoint()\n");

            if (!IsAdmin())
            {
                Assert.Fail();
            }

            #region Logical Drives

            int    cnt        = 0;
            string destFolder = Path.Combine(TempFolder, "Volume.SetVolumeMountPoint()-" + Path.GetRandomFileName());
            Directory.CreateDirectory(destFolder);

            string guid = Volume.GetUniqueVolumeNameForPath(SysDrive);

            try
            {
                StopWatcher(true);

                Volume.SetVolumeMountPoint(destFolder, guid);
                Console.WriteLine(
                    "\t#{0:000}\tSystem Drive: [{1}]\tGUID: [{2}]\n\t\tDestination : [{3}]\n\t\tCreated Mount Point.\n\t{4}",
                    ++cnt, SysDrive, guid, destFolder, Reporter(true));

                Console.WriteLine("\n");
                EnumerateVolumeMountPoints();

                Console.WriteLine("\n\nFile.GetLinkTargetInfo()");

                LinkTargetInfo lti = File.GetLinkTargetInfo(destFolder);
                Assert.IsTrue(!string.IsNullOrWhiteSpace(lti.PrintName));
                Assert.IsTrue(!string.IsNullOrWhiteSpace(lti.SubstituteName));
                Assert.IsTrue(Dump(lti, -14), "Unable to dump object.");

                // Cleanup.
                StopWatcher(true);
                bool deleteOk = false;
                try
                {
                    Volume.DeleteVolumeMountPoint(destFolder);
                    deleteOk = true;
                }
                catch (Exception ex)
                {
                    Console.WriteLine("\nCaught Exception: [{0}]\n", ex.Message.Replace(Environment.NewLine, "  "));
                }

                Console.WriteLine("\n\nVolume.DeleteVolumeMountPoint() (Should be True): [{0}]\tFolder: [{1}]\n{2}\n",
                                  deleteOk, destFolder, Reporter());

                Directory.Delete(destFolder, true, true);
                Assert.IsTrue(deleteOk && !Directory.Exists(destFolder));

                EnumerateVolumeMountPoints();
            }
            catch (Exception ex)
            {
                Console.WriteLine("\nCaught Exception: [{0}]\n", ex.Message.Replace(Environment.NewLine, "  "));
                cnt = 0;
            }
            finally
            {
                // Always remove mount point.
                // Experienced: CCleaner deletes through mount points!
                try { Volume.DeleteVolumeMountPoint(destFolder); }
                catch { }
            }

            Assert.IsTrue(cnt > 0, "Nothing was enumerated.");

            #endregion // Logical Drives
        }
Esempio n. 30
0
        private static void Main(string[] args)
        {
            ExceptionlessClient.Default.Startup("tYeWS6A5K5uItgpB44dnNy2qSb2xJxiQWRRGWebq");

            SetupNLog();

            _logger = LogManager.GetLogger("EvtxECmd");

            _fluentCommandLineParser = new FluentCommandLineParser <ApplicationArguments>
            {
                IsCaseSensitive = false
            };

            _fluentCommandLineParser.Setup(arg => arg.File)
            .As('f')
            .WithDescription("File to process. This or -d is required\r\n");
            _fluentCommandLineParser.Setup(arg => arg.Directory)
            .As('d')
            .WithDescription("Directory to process that contains evtx files. This or -f is required");

            _fluentCommandLineParser.Setup(arg => arg.CsvDirectory)
            .As("csv")
            .WithDescription(
                "Directory to save CSV formatted results to.");     // This, --json, or --xml required

            _fluentCommandLineParser.Setup(arg => arg.CsvName)
            .As("csvf")
            .WithDescription(
                "File name to save CSV formatted results to. When present, overrides default name");

            _fluentCommandLineParser.Setup(arg => arg.JsonDirectory)
            .As("json")
            .WithDescription(
                "Directory to save JSON formatted results to.");     // This, --csv, or --xml required
            _fluentCommandLineParser.Setup(arg => arg.JsonName)
            .As("jsonf")
            .WithDescription(
                "File name to save JSON formatted results to. When present, overrides default name");

            _fluentCommandLineParser.Setup(arg => arg.XmlDirectory)
            .As("xml")
            .WithDescription(
                "Directory to save XML formatted results to.");     // This, --csv, or --json required

            _fluentCommandLineParser.Setup(arg => arg.XmlName)
            .As("xmlf")
            .WithDescription(
                "File name to save XML formatted results to. When present, overrides default name\r\n");

            _fluentCommandLineParser.Setup(arg => arg.DateTimeFormat)
            .As("dt")
            .WithDescription(
                "The custom date/time format to use when displaying time stamps. Default is: yyyy-MM-dd HH:mm:ss.fffffff")
            .SetDefault("yyyy-MM-dd HH:mm:ss.fffffff");

            _fluentCommandLineParser.Setup(arg => arg.IncludeIds)
            .As("inc")
            .WithDescription(
                "List of event IDs to process. All others are ignored. Overrides --exc Format is 4624,4625,5410")
            .SetDefault(string.Empty);

            _fluentCommandLineParser.Setup(arg => arg.ExcludeIds)
            .As("exc")
            .WithDescription(
                "List of event IDs to IGNORE. All others are included. Format is 4624,4625,5410")
            .SetDefault(string.Empty);

            _fluentCommandLineParser.Setup(arg => arg.FullJson)
            .As("fj")
            .WithDescription(
                "When true, export all available data when using --json. Default is FALSE.")
            .SetDefault(false);

            _fluentCommandLineParser.Setup(arg => arg.Metrics)
            .As("met")
            .WithDescription(
                "When true, show metrics about processed event log. Default is TRUE.\r\n")
            .SetDefault(true);

            _fluentCommandLineParser.Setup(arg => arg.MapsDirectory)
            .As("maps")
            .WithDescription(
                "The path where event maps are located. Defaults to 'Maps' folder where program was executed\r\n  ")
            .SetDefault(Path.Combine(BaseDirectory, "Maps"));

            _fluentCommandLineParser.Setup(arg => arg.Debug)
            .As("debug")
            .WithDescription("Show debug information during processing").SetDefault(false);

            _fluentCommandLineParser.Setup(arg => arg.Trace)
            .As("trace")
            .WithDescription("Show trace information during processing\r\n").SetDefault(false);

            var header =
                $"EvtxECmd version {Assembly.GetExecutingAssembly().GetName().Version}" +
                "\r\n\r\nAuthor: Eric Zimmerman ([email protected])" +
                "\r\nhttps://github.com/EricZimmerman/evtx";

            var footer =
                @"Examples: EvtxECmd.exe -f ""C:\Temp\Application.evtx"" --csv ""c:\temp\out"" --csvf MyOutputFile.csv" +
                "\r\n\t " +
                @" EvtxECmd.exe -f ""C:\Temp\Application.evtx"" --csv ""c:\temp\out""" + "\r\n\t " +
                @" EvtxECmd.exe -f ""C:\Temp\Application.evtx"" --json ""c:\temp\jsonout""" + "\r\n\t " +
                "\r\n\t" +
                "  Short options (single letter) are prefixed with a single dash. Long commands are prefixed with two dashes\r\n";

            _fluentCommandLineParser.SetupHelp("?", "help")
            .WithHeader(header)
            .Callback(text => _logger.Info(text + "\r\n" + footer));

            var result = _fluentCommandLineParser.Parse(args);

            if (result.HelpCalled)
            {
                return;
            }

            if (result.HasErrors)
            {
                _logger.Error("");
                _logger.Error(result.ErrorText);

                _fluentCommandLineParser.HelpOption.ShowHelp(_fluentCommandLineParser.Options);

                return;
            }

            if (_fluentCommandLineParser.Object.File.IsNullOrEmpty() &&
                _fluentCommandLineParser.Object.Directory.IsNullOrEmpty())
            {
                _fluentCommandLineParser.HelpOption.ShowHelp(_fluentCommandLineParser.Options);

                _logger.Warn("-f or -d is required. Exiting");
                return;
            }

            _logger.Info(header);
            _logger.Info("");
            _logger.Info($"Command line: {string.Join(" ", Environment.GetCommandLineArgs().Skip(1))}\r\n");

            if (IsAdministrator() == false)
            {
                _logger.Fatal("Warning: Administrator privileges not found!\r\n");
            }

            if (_fluentCommandLineParser.Object.Debug)
            {
                LogManager.Configuration.LoggingRules.First().EnableLoggingForLevel(LogLevel.Debug);
            }

            if (_fluentCommandLineParser.Object.Trace)
            {
                LogManager.Configuration.LoggingRules.First().EnableLoggingForLevel(LogLevel.Trace);
            }

            LogManager.ReconfigExistingLoggers();

            var sw = new Stopwatch();

            sw.Start();

            var ts = DateTimeOffset.UtcNow;

            _errorFiles = new Dictionary <string, int>();

            if (_fluentCommandLineParser.Object.JsonDirectory.IsNullOrEmpty() == false)
            {
                if (Directory.Exists(_fluentCommandLineParser.Object.JsonDirectory) == false)
                {
                    _logger.Warn(
                        $"Path to '{_fluentCommandLineParser.Object.JsonDirectory}' doesn't exist. Creating...");

                    try
                    {
                        Directory.CreateDirectory(_fluentCommandLineParser.Object.JsonDirectory);
                    }
                    catch (Exception)
                    {
                        _logger.Fatal(
                            $"Unable to create directory '{_fluentCommandLineParser.Object.JsonDirectory}'. Does a file with the same name exist? Exiting");
                        return;
                    }
                }

                var outName = $"{ts:yyyyMMddHHmmss}_EvtxECmd_Output.json";

                if (_fluentCommandLineParser.Object.JsonName.IsNullOrEmpty() == false)
                {
                    outName = Path.GetFileName(_fluentCommandLineParser.Object.JsonName);
                }

                var outFile = Path.Combine(_fluentCommandLineParser.Object.JsonDirectory, outName);

                _logger.Warn($"json output will be saved to '{outFile}'\r\n");



                try
                {
                    _swJson = new StreamWriter(outFile, false, Encoding.UTF8);
                }
                catch (Exception)
                {
                    _logger.Error($"Unable to open '{outFile}'! Is it in use? Exiting!\r\n");
                    Environment.Exit(0);
                }
            }

            if (_fluentCommandLineParser.Object.XmlDirectory.IsNullOrEmpty() == false)
            {
                if (Directory.Exists(_fluentCommandLineParser.Object.XmlDirectory) == false)
                {
                    _logger.Warn(
                        $"Path to '{_fluentCommandLineParser.Object.XmlDirectory}' doesn't exist. Creating...");

                    try
                    {
                        Directory.CreateDirectory(_fluentCommandLineParser.Object.XmlDirectory);
                    }
                    catch (Exception)
                    {
                        _logger.Fatal(
                            $"Unable to create directory '{_fluentCommandLineParser.Object.XmlDirectory}'. Does a file with the same name exist? Exiting");
                        return;
                    }
                }

                var outName = $"{ts:yyyyMMddHHmmss}_EvtxECmd_Output.xml";

                if (_fluentCommandLineParser.Object.XmlName.IsNullOrEmpty() == false)
                {
                    outName = Path.GetFileName(_fluentCommandLineParser.Object.XmlName);
                }

                var outFile = Path.Combine(_fluentCommandLineParser.Object.XmlDirectory, outName);

                _logger.Warn($"XML output will be saved to '{outFile}'\r\n");

                try
                {
                    _swXml = new StreamWriter(outFile, false, Encoding.UTF8);
                }
                catch (Exception)
                {
                    _logger.Error($"Unable to open '{outFile}'! Is it in use? Exiting!\r\n");
                    Environment.Exit(0);
                }
            }

            if (_fluentCommandLineParser.Object.CsvDirectory.IsNullOrEmpty() == false)
            {
                if (Directory.Exists(_fluentCommandLineParser.Object.CsvDirectory) == false)
                {
                    _logger.Warn(
                        $"Path to '{_fluentCommandLineParser.Object.CsvDirectory}' doesn't exist. Creating...");

                    try
                    {
                        Directory.CreateDirectory(_fluentCommandLineParser.Object.CsvDirectory);
                    }
                    catch (Exception)
                    {
                        _logger.Fatal(
                            $"Unable to create directory '{_fluentCommandLineParser.Object.CsvDirectory}'. Does a file with the same name exist? Exiting");
                        return;
                    }
                }

                var outName = $"{ts:yyyyMMddHHmmss}_EvtxECmd_Output.csv";

                if (_fluentCommandLineParser.Object.CsvName.IsNullOrEmpty() == false)
                {
                    outName = Path.GetFileName(_fluentCommandLineParser.Object.CsvName);
                }

                var outFile = Path.Combine(_fluentCommandLineParser.Object.CsvDirectory, outName);

                _logger.Warn($"CSV output will be saved to '{outFile}'\r\n");

                try
                {
                    _swCsv = new StreamWriter(outFile, false, Encoding.UTF8);

                    _csvWriter = new CsvWriter(_swCsv);
                }
                catch (Exception)
                {
                    _logger.Error($"Unable to open '{outFile}'! Is it in use? Exiting!\r\n");
                    Environment.Exit(0);
                }

                var foo = _csvWriter.Configuration.AutoMap <EventRecord>();

                foo.Map(t => t.PayloadXml).Ignore();
                foo.Map(t => t.RecordPosition).Ignore();
                foo.Map(t => t.Size).Ignore();
                foo.Map(t => t.Timestamp).Ignore();

                foo.Map(t => t.RecordNumber).Index(0);
                foo.Map(t => t.TimeCreated).Index(1);
                foo.Map(t => t.TimeCreated).ConvertUsing(t =>
                                                         $"{t.TimeCreated.ToString(_fluentCommandLineParser.Object.DateTimeFormat)}");
                foo.Map(t => t.EventId).Index(2);
                foo.Map(t => t.Level).Index(3);
                foo.Map(t => t.Provider).Index(4);
                foo.Map(t => t.Channel).Index(5);
                foo.Map(t => t.ProcessId).Index(6);
                foo.Map(t => t.ThreadId).Index(7);
                foo.Map(t => t.Computer).Index(8);
                foo.Map(t => t.UserId).Index(9);
                foo.Map(t => t.MapDescription).Index(10);
                foo.Map(t => t.UserName).Index(11);
                foo.Map(t => t.RemoteHost).Index(12);
                foo.Map(t => t.PayloadData1).Index(13);
                foo.Map(t => t.PayloadData2).Index(14);
                foo.Map(t => t.PayloadData3).Index(15);
                foo.Map(t => t.PayloadData4).Index(16);
                foo.Map(t => t.PayloadData5).Index(17);
                foo.Map(t => t.PayloadData6).Index(18);
                foo.Map(t => t.ExecutableInfo).Index(19);
                foo.Map(t => t.SourceFile).Index(20);

                _csvWriter.Configuration.RegisterClassMap(foo);
                _csvWriter.WriteHeader <EventRecord>();
                _csvWriter.NextRecord();
            }

            if (Directory.Exists(_fluentCommandLineParser.Object.MapsDirectory) == false)
            {
                _logger.Warn(
                    $"Maps directory '{_fluentCommandLineParser.Object.MapsDirectory}' does not exist! Event ID maps will not be loaded!!");
            }
            else
            {
                _logger.Debug($"Loading maps from '{Path.GetFullPath(_fluentCommandLineParser.Object.MapsDirectory)}'");
                var errors = EventLog.LoadMaps(Path.GetFullPath(_fluentCommandLineParser.Object.MapsDirectory));


                if (errors)
                {
                    return;
                }

                _logger.Info($"Maps loaded: {EventLog.EventLogMaps.Count:N0}");
            }

            _includeIds = new HashSet <int>();
            _excludeIds = new HashSet <int>();

            if (_fluentCommandLineParser.Object.ExcludeIds.IsNullOrEmpty() == false)
            {
                var excSegs = _fluentCommandLineParser.Object.ExcludeIds.Split(',');

                foreach (var incSeg in excSegs)
                {
                    if (int.TryParse(incSeg, out var goodId))
                    {
                        _excludeIds.Add(goodId);
                    }
                }
            }

            if (_fluentCommandLineParser.Object.IncludeIds.IsNullOrEmpty() == false)
            {
                _excludeIds.Clear();
                var incSegs = _fluentCommandLineParser.Object.IncludeIds.Split(',');

                foreach (var incSeg in incSegs)
                {
                    if (int.TryParse(incSeg, out var goodId))
                    {
                        _includeIds.Add(goodId);
                    }
                }
            }


            if (_fluentCommandLineParser.Object.File.IsNullOrEmpty() == false)
            {
                if (File.Exists(_fluentCommandLineParser.Object.File) == false)
                {
                    _logger.Warn($"'{_fluentCommandLineParser.Object.File}' does not exist! Exiting");
                    return;
                }

                ProcessFile(_fluentCommandLineParser.Object.File);
            }
            else
            {
                _logger.Info($"Looking for event log files in '{_fluentCommandLineParser.Object.Directory}'");
                _logger.Info("");

                var f = new DirectoryEnumerationFilters();
                f.InclusionFilter = fsei => fsei.Extension.ToUpperInvariant() == ".EVTX";

                f.RecursionFilter = entryInfo => !entryInfo.IsMountPoint && !entryInfo.IsSymbolicLink;

                f.ErrorFilter = (errorCode, errorMessage, pathProcessed) => true;

                var dirEnumOptions =
                    DirectoryEnumerationOptions.Files | DirectoryEnumerationOptions.Recursive |
                    DirectoryEnumerationOptions.SkipReparsePoints | DirectoryEnumerationOptions.ContinueOnException |
                    DirectoryEnumerationOptions.BasicSearch;

                var files2 =
                    Directory.EnumerateFileSystemEntries(Path.GetFullPath(_fluentCommandLineParser.Object.Directory), dirEnumOptions, f);

                foreach (var file in files2)
                {
                    ProcessFile(file);
                }
            }

            _swCsv?.Flush();
            _swCsv?.Close();

            _swJson?.Flush();
            _swJson?.Close();

            _swXml?.Flush();
            _swXml?.Close();

            sw.Stop();
            _logger.Info("");

            var suff = string.Empty;

            if (_fileCount != 1)
            {
                suff = "s";
            }

            _logger.Error(
                $"Processed {_fileCount:N0} file{suff} in {sw.Elapsed.TotalSeconds:N4} seconds\r\n");

            if (_errorFiles.Count > 0)
            {
                _logger.Info("");
                _logger.Error("Files with errors");
                foreach (var errorFile in _errorFiles)
                {
                    _logger.Info($"'{errorFile.Key}' error count: {errorFile.Value:N0}");
                }

                _logger.Info("");
            }
        }
Esempio n. 31
0
 public static bool FileExists(this string filename)
 {
     return(File.Exists(filename));
 }
Esempio n. 32
0
 public FileStream OpenWrite()
 {
     return(File.OpenWrite(_path));
 }
        /// <summary>
        /// Documentation: https://developers.google.com/drive/v2/reference/files/insert
        /// </summary>
        /// <param name="_service"></param>
        /// <param name="_name"></param>
        /// <param name="_description"></param>
        /// <param name="_parent"></param>
        /// <returns></returns>
        public static Moss createDirectory(DriveService _service, string _name, string _description, string _parent)
        {
            if (_name == null || _parent == null)
            {
                log.Error("Exception[2.1]: Folder name or parent are null. " + _name + "| " + _parent);
                return new Moss();
            }

            Pause();
            log.Info("Create catalog: " + _name);
            File NewDirectory = null;
            Moss returnValue = new Moss();
            Dictionary<string, string> dictionary = new Dictionary<string, string>();

            File body = new File();
            body.Name = _name;
            body.Description = _description;
            body.MimeType = "application/vnd.google-apps.folder";
            body.Parents = new List<string> { _parent };
            body.Properties = dictionary;

            var request = _service.Files.Create(body);
            request.Fields = "id, name, parents, md5Checksum, description, mimeType";

            do
            {
                try
                {
                    NewDirectory = request.Execute();
                }
                catch (Exception x) { log.Error("Exception[2]: " + x.Message + " | " + x); Task.Delay(3000).Wait(); continue; }
            }
            while (NewDirectory == null);

            Application.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() =>
            {
                ((MainWindow)Application.Current.MainWindow).lb_currUpload.Content = "Folder: " + @_name + " successful created";
            }));

            if (NewDirectory.Id != null && NewDirectory.MimeType != null && NewDirectory.Name != null && NewDirectory.Parents[0] != null)
            {
                returnValue.Id = NewDirectory.Id;
                returnValue.mimeType = NewDirectory.MimeType;
                returnValue.Name = NewDirectory.Name;
                returnValue.parents = NewDirectory.Parents[0];
            }
            return returnValue;
        }
        /// <summary>
        /// Documentation: https://developers.google.com/drive/v3/reference/files/insert
        /// </summary>
        /// <param name="_service"></param>
        /// <param name="_uploadFile"></param>
        /// <param name="_parent"></param>
        /// <param name="Description"></param>
        /// <returns></returns>
        public static File uploadFile(DriveService _service, string _uploadFile, string _parent, string Description)
        {
            log.Warn("[UPLOAD]: " + _uploadFile + " To Parent: " + _parent);
            //return null;

            Pause();
            log.Info("Upload file: " + _uploadFile);
            if (Alpha.File.Exists(_uploadFile))
            {
                File body = new File();
                string name = Alpha.Path.GetFileName(_uploadFile);
                FileName = name;
                _ChunkSize = 0;

                body.Name = name;
                body.MimeType = GetMimeType(_uploadFile);
                body.Parents = new List<string> { _parent };
                fileSize = Alpha.File.GetSize(_uploadFile);

                using (var stream = Alpha.File.OpenRead(_uploadFile))
                {
                    var request = _service.Files.Create(body, stream, body.MimeType);
                    try
                    {
                        request.ChunkSize = 1048576;
                        _ChunkSize = 1048576;

                        request.ProgressChanged += Upload_ProgressChanged;
                        var _watch = Stopwatch.StartNew();
                        request.Upload();
                        _watch.Stop();
                        log.Warn("[" + FileName + "]" + " | File Size: " + fileSize + "| Send Time: [" + _watch.ElapsedMilliseconds + "]");

                        while (request.ContentStream.Position != request.ContentStream.Length)
                        {
                            Pause();
                            log.Error("Network error. Resume attempt.");
                            for (int i = 15; i > 0; i = i - 1)
                            {
                                Application.Current.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(() =>
                                    {
                                        ((MainWindow)Application.Current.MainWindow).lb_currUpload.Content = "Network error. Resume attempt in: " + i;
                                    }));
                                Thread.Sleep(1000);
                            }
                            request.Resume();
                        }
                    }
                    catch (Exception x) { log.Error("Exception[5]: " + x.Message + " | " + x); return null; }
                    return request.ResponseBody;
                }
            }
            else
            {
                log.Error("File not found: " + _uploadFile);
                return null;
            }
        }