Example #1
0
        private void Execute(VerifyChecksumsExecute execute)
        {
            // set up reporting
            ParseExcel report = null;

            if (execute.Request.Report)
            {
                report = new ParseExcel();
                report.StartFileSheet();
            }

            var hasher = execute.HashType.ToString();

            using (var algorithm = HashCalc.GetHashAlgorithm(execute.HashType))
            {
                // query file system
                var query       = new QueryHashSystem();
                var queryResult = query.Execute(execute.InputFileUri);

                // enumerate and hash files
                int  fileCount          = 0;
                long totalDataProcessed = 0;
                var  files = new List <FileInfo>();
                foreach (var entry in queryResult.Entries)
                {
                    var fileName = entry.Key;
                    var file     = new FileInfo(fileName);
                    files.Add(file);

                    var status = "PREVIEW";
                    //execute.AddState(execute.Request, )
                    //UpdateState(execute.Request, )

                    try
                    {
                        fileCount++;
                        var log = new StringBuilder();
                        log.Append($"{fileCount}. {fileName} -> {hasher} = ");

                        // calculate hash and output hash to log
                        var    hash  = hasher;
                        string error = null;
                        if (!execute.Request.Preview)
                        {
                            try
                            {
                                hash = HashCalc.GetHash(fileName, algorithm);
                                var match = (String.Compare(hash, entry.Value, true) == 0);
                                if (match)
                                {
                                    status = "VALID";
                                }
                                else
                                {
                                    error  = "Hash Invalid";
                                    status = "INVALID";
                                    execute.LogError(entry.Key, new Exception(error));
                                }
                            }
                            catch (DirectoryNotFoundException)
                            {
                                status = "MISSING";
                                error  = "Not Found";
                            }
                            catch (FileNotFoundException)
                            {
                                status = "MISSING";
                                error  = "Not Found";
                            }
                            catch (Exception ex)
                            {
                                status = "ERROR";
                                error  = ex.Message;
                            }
                        }

                        // write report data if requested
                        report?.AddFileInfo(file, status, hash, error);

                        // display to output
                        log.Append($"{hash} {status}");
                        execute.LogLine(log.ToString());

                        // update totals
                        totalDataProcessed += file.Length;
                    }
                    catch (Exception ex)
                    {
                        execute.LogError(entry.Key, ex);
                    }
                }

                // show output
                var time = DateTime.Now.Subtract(execute.Request.Started);
                var mb   = totalDataProcessed / 1024.0 / 1024.0;
                var gb   = mb / 1024;
                var tb   = gb / 1024;
                var gbh  = gb / time.TotalHours;
                var mbs  = mb / time.TotalMinutes;
                execute.LogLine($"==================================================");
                execute.LogLine($"FILES: {files.Count:###,###,###,###,###,##0}");
                execute.LogLine($"BYTES: {totalDataProcessed:###,###,###,###,###,##0} = {gb:###,###,###,###,###,##0} GB = {tb:###,###,###,###,###,##0} TB");
                execute.LogLine($"TIME: {time:hh\\:mm\\:ss} H:M:S = {time.TotalSeconds:###,###,###,###,##0} SEC");
                execute.LogLine($"--------------------------------------------------");
                execute.LogLine($"RATE: {gbh:##,##0.0} GB/HOUR = {mbs:##,##0.0} MB/SEC");

                if (execute.Exceptions.Count > 0)
                {
                    execute.LogLine($"##################################################");
                    execute.LogLine($"EXCEPTIONS: {execute.Exceptions.Count()}");
                }

                // close out report
                if (report != null)
                {
                    execute.LogLine($"--------------------------------------------------");
                    execute.LogLine($"SAVING REPORT: {execute.ReportFileUri}");
                    report.SaveAs(execute.ReportFileUri);
                }
            }
        }
        private void Execute(CreateChecksumsExecute execute)
        {
            // set up hashing
            StreamWriter output = null;

            if (!execute.Request.Preview)
            {
                output = File.CreateText(execute.OutputFileUri);
            }

            // set up reporting
            ParseExcel report = null;

            if (execute.Request.Report)
            {
                report = new ParseExcel();
                report.StartFileSheet();
            }

            long totalDataProcessed = 0;
            var  hasher             = execute.Request.HashType.ToString();

            using (var algorithm = HashCalc.GetHashAlgorithm(execute.Request.HashType))
            {
                output?.WriteLine($"# Generated {hasher} with Expedition at {DateTime.Now}");
                output?.WriteLine($"# https://github.com/DesignedSimplicity/Expedition/");
                output?.WriteLine("");

                // query file system
                var query = new QueryFileSystem();
                //TODO attach event handler here
                execute.Request.Silent = true;
                var queryResult = query.Execute(execute.Request);

                // enumerate and hash files
                int count = 0;
                var files = new List <FileInfo>();
                foreach (var file in queryResult.Files)
                {
                    string hash     = null;
                    var    fileName = file.FullName;

                    // exclude/skip output file
                    if (String.Compare(execute.OutputFileUri, fileName, true) == 0)
                    {
                        continue;
                    }

                    try
                    {
                        count++;
                        files.Add(file);
                        execute.SetState(new BaseFileSytemState(file));
                        execute.Log($"{count}. {fileName} -> {file.Length:###,###,###,###,##0}");
                        if (execute.Request.Preview)
                        {
                            execute.LogLine($" LOG");
                        }
                        else
                        {
                            // calculate hash and output hash to log
                            var s = new Stopwatch();
                            s.Start();
                            hash = HashCalc.GetHash(fileName, algorithm);
                            var rate = file.Length / (s.ElapsedMilliseconds + 1);
                            s.Stop();
                            execute.LogLine($" {hasher} = {hash} @ {rate:###,###,###,###,##0} b/ms");
                        }

                        // format and write checksum to stream
                        var path = execute.GetOuputPath(fileName);
                        output?.WriteLine($"{hash} {path}");

                        // update file data state
                        totalDataProcessed += file.Length;
                        execute.SetState(new BaseFileSytemState(file, hash));

                        // write report data if requested
                        report?.AddFileInfo(file, null, hash);
                    }
                    catch (Exception ex)
                    {
                        execute.LogError(fileName, ex);
                        execute.SetState(new BaseFileSytemState(file, ex));
                        report?.AddFileInfo(file, null, hash, ex.Message);
                    }
                }

                // gather output files
                execute.Files = files.ToArray();

                // show output
                var time = DateTime.Now.Subtract(execute.Request.Started);
                var mb   = totalDataProcessed / 1024.0 / 1024.0;
                var gb   = mb / 1024;
                var tb   = gb / 1024;
                var gbh  = gb / time.TotalHours;
                var mbs  = mb / time.TotalMinutes;
                execute.LogLine($"==================================================");
                execute.LogLine($"FILES: {files.Count:###,###,###,###,###,##0}");
                execute.LogLine($"BYTES: {totalDataProcessed:###,###,###,###,###,##0} = {gb:###,###,###,###,###,##0} GB = {tb:###,###,###,###,###,##0} TB");
                execute.LogLine($"TIME: {time:hh\\:mm\\:ss} H:M:S = {time.TotalSeconds:###,###,###,###,##0} SEC");
                execute.LogLine($"--------------------------------------------------");
                execute.LogLine($"RATE: {gbh:##,##0.0} GB/HOUR = {mbs:##,##0.0} MB/SEC");

                if (queryResult.Errors.Count > 0)
                {
                    execute.LogLine($"##################################################");
                    execute.LogLine($"QUERY ERRORS: {queryResult.Errors.Count}");
                }
                if (execute.Exceptions.Count > 0)
                {
                    execute.LogLine($"##################################################");
                    execute.LogLine($"EXCEPTIONS: {execute.Exceptions.Count()}");
                }

                // clean up output file
                if (output != null)
                {
                    execute.LogLine($"==================================================");
                    execute.LogLine($"SAVING HASHES: {execute.OutputFileUri}");
                    output?.Flush();
                    output?.Close();
                    output?.Dispose();
                }

                // close out report
                if (report != null)
                {
                    execute.LogLine($"--------------------------------------------------");
                    execute.LogLine($"SAVING REPORT: {execute.ReportFileUri}");
                    report.SaveAs(execute.ReportFileUri);
                }
            }
        }