Changeset 1622


Ignore:
Timestamp:
01/19/10 12:45:16 (5 years ago)
Author:
lowjoel
Message:

Combine the progress and upload steps to the Upload function since compression of the report is strictly the task of the Report Uploader. Addresses #307: Eraser Updater restructuring

Location:
branches/eraser6/CodeReview
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/eraser6/CodeReview/Eraser.Util/BlackBox.cs

    r1620 r1622  
    544544 
    545545        /// <summary> 
    546         /// Verifies the stack trace against the server to see if the report is new. 
    547         /// </summary> 
    548         /// <returns>True if the report is new; false otherwise</returns> 
    549         public bool ReportIsNew() 
    550         { 
    551             PostDataBuilder builder = new PostDataBuilder(); 
    552             builder.AddPart(new PostDataField("action", "status")); 
    553             AddStackTraceToRequest(Report.StackTrace, builder); 
    554  
    555             WebRequest reportRequest = HttpWebRequest.Create(BlackBoxServer); 
    556             reportRequest.ContentType = builder.ContentType; 
    557             reportRequest.Method = "POST"; 
    558             using (Stream formStream = builder.Stream) 
    559             { 
    560                 reportRequest.ContentLength = formStream.Length; 
    561                 using (Stream requestStream = reportRequest.GetRequestStream()) 
    562                 { 
    563                     int lastRead = 0; 
    564                     byte[] buffer = new byte[32768]; 
    565                     while ((lastRead = formStream.Read(buffer, 0, buffer.Length)) != 0) 
    566                         requestStream.Write(buffer, 0, lastRead); 
    567                 } 
    568             } 
    569  
    570             try 
    571             { 
    572                 HttpWebResponse response = reportRequest.GetResponse() as HttpWebResponse; 
    573                 using (Stream responseStream = response.GetResponseStream()) 
    574                 { 
    575                     XmlReader reader = XmlReader.Create(responseStream); 
    576                     reader.ReadToFollowing("crashReport"); 
    577                     string reportStatus = reader.GetAttribute("status"); 
    578                     switch (reportStatus) 
    579                     { 
    580                         case "exists": 
    581                             Report.Submitted = true; 
    582                             return false; 
    583  
    584                         case "new": 
    585                             return true; 
    586  
    587                         default: 
    588                             throw new InvalidDataException("Unknown crash report server response."); 
    589                     } 
    590                 } 
    591             } 
    592             catch (WebException e) 
    593             { 
    594                 using (Stream responseStream = e.Response.GetResponseStream()) 
    595                 { 
    596                     try 
    597                     { 
    598                         XmlReader reader = XmlReader.Create(responseStream); 
    599                         reader.ReadToFollowing("error"); 
    600                         throw new InvalidDataException(string.Format(CultureInfo.CurrentCulture, 
    601                             "The server encountered a problem while processing the request: {0}", 
    602                             reader.ReadString())); 
    603                     } 
    604                     catch (XmlException) 
    605                     { 
    606                     } 
    607                 } 
    608  
    609                 throw new InvalidDataException(((HttpWebResponse)e.Response).StatusDescription); 
    610             } 
    611         } 
    612  
    613         public void Compress(ProgressChangedEventHandler progressChanged) 
    614         { 
    615             using (FileStream archiveStream = new FileStream(ReportBaseName + ".tar", 
    616                     FileMode.Create, FileAccess.Write)) 
    617             { 
    618                 //Add the report into a tar file 
    619                 TarArchive archive = TarArchive.CreateOutputTarArchive(archiveStream); 
    620                 foreach (FileInfo file in Report.Files) 
    621                 { 
    622                     TarEntry entry = TarEntry.CreateEntryFromFile(file.FullName); 
    623                     entry.Name = Path.GetFileName(entry.Name); 
    624                     archive.WriteEntry(entry, false); 
    625                 } 
    626                 archive.Close(); 
    627             } 
    628  
    629             ProgressManager progress = new ProgressManager(); 
    630             using (FileStream bzipFile = new FileStream(ReportBaseName + ".tbz", 
    631                 FileMode.Create)) 
    632             using (FileStream tarStream = new FileStream(ReportBaseName + ".tar", 
    633                 FileMode.Open, FileAccess.Read, FileShare.Read, 262144, FileOptions.DeleteOnClose)) 
    634             using (BZip2OutputStream bzipStream = new BZip2OutputStream(bzipFile, 262144)) 
    635             { 
    636                 //Compress the tar file 
    637                 int lastRead = 0; 
    638                 byte[] buffer = new byte[524288]; 
    639                 while ((lastRead = tarStream.Read(buffer, 0, buffer.Length)) != 0) 
    640                 { 
    641                     bzipStream.Write(buffer, 0, lastRead); 
    642                     progress.Completed = tarStream.Position; 
    643                     progress.Total = tarStream.Length; 
    644                     progressChanged(this, new ProgressChangedEventArgs(progress, null)); 
    645                 } 
    646             } 
    647         } 
    648  
    649         public void Upload(ProgressChangedEventHandler progressChanged) 
    650         { 
    651             using (FileStream bzipFile = new FileStream(ReportBaseName + ".tbz", 
    652                 FileMode.Open, FileAccess.Read, FileShare.Read, 131072, FileOptions.DeleteOnClose)) 
    653             using (Stream logFile = Report.DebugLog) 
    654             { 
    655                 //Build the POST request 
     546        /// Gets from the server based on the stack trace whether this report is 
     547        /// new. 
     548        /// </summary> 
     549        public bool IsNew 
     550        { 
     551            get 
     552            { 
    656553                PostDataBuilder builder = new PostDataBuilder(); 
    657                 builder.AddPart(new PostDataField("action", "upload")); 
    658                 builder.AddPart(new PostDataFileField("crashReport", "Report.tbz", bzipFile)); 
     554                builder.AddPart(new PostDataField("action", "status")); 
    659555                AddStackTraceToRequest(Report.StackTrace, builder); 
    660556 
    661                 //Upload the POST request 
    662557                WebRequest reportRequest = HttpWebRequest.Create(BlackBoxServer); 
    663558                reportRequest.ContentType = builder.ContentType; 
    664559                reportRequest.Method = "POST"; 
    665                 reportRequest.Timeout = int.MaxValue; 
    666560                using (Stream formStream = builder.Stream) 
    667561                { 
    668562                    reportRequest.ContentLength = formStream.Length; 
    669                     ProgressManager progress = new ProgressManager(); 
    670563                    using (Stream requestStream = reportRequest.GetRequestStream()) 
    671564                    { 
     
    673566                        byte[] buffer = new byte[32768]; 
    674567                        while ((lastRead = formStream.Read(buffer, 0, buffer.Length)) != 0) 
     568                            requestStream.Write(buffer, 0, lastRead); 
     569                    } 
     570                } 
     571 
     572                try 
     573                { 
     574                    HttpWebResponse response = reportRequest.GetResponse() as HttpWebResponse; 
     575                    using (Stream responseStream = response.GetResponseStream()) 
     576                    { 
     577                        XmlReader reader = XmlReader.Create(responseStream); 
     578                        reader.ReadToFollowing("crashReport"); 
     579                        string reportStatus = reader.GetAttribute("status"); 
     580                        switch (reportStatus) 
    675581                        { 
    676                             requestStream.Write(buffer, 0, lastRead); 
    677  
    678                             progress.Completed = formStream.Position; 
    679                             progress.Total = formStream.Length; 
    680                             progressChanged(this, new ProgressChangedEventArgs(progress, null)); 
     582                            case "exists": 
     583                                Report.Submitted = true; 
     584                                return false; 
     585 
     586                            case "new": 
     587                                return true; 
     588 
     589                            default: 
     590                                throw new InvalidDataException( 
     591                                    "Unknown crash report server response."); 
    681592                        } 
    682593                    } 
    683                 } 
    684  
    685                 try 
    686                 { 
    687                     reportRequest.GetResponse(); 
    688                     Report.Submitted = true; 
    689594                } 
    690595                catch (WebException e) 
     
    711616 
    712617        /// <summary> 
     618        /// Compresses the report for uploading. 
     619        /// </summary> 
     620        /// <param name="progress">The <see cref="ProgressManager"/> instance that the 
     621        /// Upload function is using.</param> 
     622        /// <param name="progressChanged">The progress changed event handler that should 
     623        /// be called for upload progress updates.</param> 
     624        private void Compress(SteppedProgressManager progress, 
     625            ProgressChangedEventHandler progressChanged) 
     626        { 
     627            using (FileStream archiveStream = new FileStream(ReportBaseName + ".tar", 
     628                    FileMode.Create, FileAccess.Write)) 
     629            { 
     630                //Add the report into a tar file 
     631                TarArchive archive = TarArchive.CreateOutputTarArchive(archiveStream); 
     632                foreach (FileInfo file in Report.Files) 
     633                { 
     634                    TarEntry entry = TarEntry.CreateEntryFromFile(file.FullName); 
     635                    entry.Name = Path.GetFileName(entry.Name); 
     636                    archive.WriteEntry(entry, false); 
     637                } 
     638                archive.Close(); 
     639            } 
     640 
     641            ProgressManager step = new ProgressManager(); 
     642            progress.Steps.Add(new SteppedProgressManagerStep(step, 0.5f, "Compressing")); 
     643            using (FileStream bzipFile = new FileStream(ReportBaseName + ".tbz", 
     644                FileMode.Create)) 
     645            using (FileStream tarStream = new FileStream(ReportBaseName + ".tar", 
     646                FileMode.Open, FileAccess.Read, FileShare.Read, 262144, FileOptions.DeleteOnClose)) 
     647            using (BZip2OutputStream bzipStream = new BZip2OutputStream(bzipFile, 262144)) 
     648            { 
     649                //Compress the tar file 
     650                int lastRead = 0; 
     651                byte[] buffer = new byte[524288]; 
     652                while ((lastRead = tarStream.Read(buffer, 0, buffer.Length)) != 0) 
     653                { 
     654                    bzipStream.Write(buffer, 0, lastRead); 
     655                    step.Completed = tarStream.Position; 
     656                    step.Total = tarStream.Length; 
     657 
     658                    if (progressChanged != null) 
     659                        progressChanged(this, new ProgressChangedEventArgs(progress, null)); 
     660                } 
     661            } 
     662        } 
     663 
     664        /// <summary> 
     665        /// Compresses the report, then uploads it to the server. 
     666        /// </summary> 
     667        /// <param name="progressChanged">The progress changed event handler that should 
     668        /// be called for upload progress updates.</param> 
     669        public void Submit(ProgressChangedEventHandler progressChanged) 
     670        { 
     671            SteppedProgressManager overallProgress = new SteppedProgressManager(); 
     672            Compress(overallProgress, progressChanged); 
     673 
     674            using (FileStream bzipFile = new FileStream(ReportBaseName + ".tbz", 
     675                FileMode.Open, FileAccess.Read, FileShare.Read, 131072, FileOptions.DeleteOnClose)) 
     676            using (Stream logFile = Report.DebugLog) 
     677            { 
     678                //Build the POST request 
     679                PostDataBuilder builder = new PostDataBuilder(); 
     680                builder.AddPart(new PostDataField("action", "upload")); 
     681                builder.AddPart(new PostDataFileField("crashReport", "Report.tbz", bzipFile)); 
     682                AddStackTraceToRequest(Report.StackTrace, builder); 
     683 
     684                //Upload the POST request 
     685                WebRequest reportRequest = HttpWebRequest.Create(BlackBoxServer); 
     686                reportRequest.ContentType = builder.ContentType; 
     687                reportRequest.Method = "POST"; 
     688                reportRequest.Timeout = int.MaxValue; 
     689                using (Stream formStream = builder.Stream) 
     690                { 
     691                    ProgressManager progress = new ProgressManager(); 
     692                    overallProgress.Steps.Add(new SteppedProgressManagerStep( 
     693                        progress, 0.5f, "Uploading")); 
     694                    reportRequest.ContentLength = formStream.Length; 
     695 
     696                    using (Stream requestStream = reportRequest.GetRequestStream()) 
     697                    { 
     698                        int lastRead = 0; 
     699                        byte[] buffer = new byte[32768]; 
     700                        while ((lastRead = formStream.Read(buffer, 0, buffer.Length)) != 0) 
     701                        { 
     702                            requestStream.Write(buffer, 0, lastRead); 
     703 
     704                            progress.Completed = formStream.Position; 
     705                            progress.Total = formStream.Length; 
     706                            progressChanged(this, new ProgressChangedEventArgs(overallProgress, null)); 
     707                        } 
     708                    } 
     709                } 
     710 
     711                try 
     712                { 
     713                    reportRequest.GetResponse(); 
     714                    Report.Submitted = true; 
     715                } 
     716                catch (WebException e) 
     717                { 
     718                    using (Stream responseStream = e.Response.GetResponseStream()) 
     719                    { 
     720                        try 
     721                        { 
     722                            XmlReader reader = XmlReader.Create(responseStream); 
     723                            reader.ReadToFollowing("error"); 
     724                            throw new InvalidDataException(string.Format(CultureInfo.CurrentCulture, 
     725                                "The server encountered a problem while processing the request: {0}", 
     726                                reader.ReadString())); 
     727                        } 
     728                        catch (XmlException) 
     729                        { 
     730                        } 
     731                    } 
     732 
     733                    throw new InvalidDataException(((HttpWebResponse)e.Response).StatusDescription); 
     734                } 
     735            } 
     736        } 
     737 
     738        /// <summary> 
    713739        /// Adds the stack trace to the given form request. 
    714740        /// </summary> 
  • branches/eraser6/CodeReview/Eraser/BlackBoxUploadForm.cs

    r1617 r1622  
    6363        { 
    6464            IList<BlackBoxReport> reports = (IList<BlackBoxReport>)e.Argument; 
    65             SteppedProgressManager progress = new SteppedProgressManager(); 
     65            SteppedProgressManager overallProgress = new SteppedProgressManager(); 
    6666 
    6767            for (int i = 0; i < reports.Count; ++i) 
    6868            { 
    6969                //Create the progress object that will handle the progress for this report. 
    70                 SteppedProgressManager reportProgress = new SteppedProgressManager(); 
    71                 progress.Steps.Add(new SteppedProgressManagerStep(reportProgress, 
     70                ProgressManager reportProgress = new ProgressManager(); 
     71                overallProgress.Steps.Add(new SteppedProgressManagerStep(reportProgress, 
    7272                    1.0f / reports.Count)); 
    7373 
     
    7575 
    7676                //Check that a similar report has not yet been uploaded. 
    77                 UploadWorker.ReportProgress((int)(progress.Progress * 100), 
     77                UploadWorker.ReportProgress((int)(overallProgress.Progress * 100), 
    7878                    S._("Checking for status of report {0}...", reports[i].Name)); 
    79                 if (!uploader.ReportIsNew()) 
     79                if (!uploader.IsNew) 
    8080                    continue; 
    8181 
     
    8383                    throw new OperationCanceledException(); 
    8484 
    85                 { 
    86                     //No similar reports have been uploaded. Compress the report. 
    87                     ProgressManager step = new ProgressManager(); 
    88                     step.Total = 1000; 
    89                     reportProgress.Steps.Add(new SteppedProgressManagerStep(step, 0.5f)); 
    90                     UploadWorker.ReportProgress((int)(progress.Progress * 100), 
    91                         S._("Compressing Report {0}: {1}%", reports[i].Name, 0)); 
     85                //Upload the report. 
     86                UploadWorker.ReportProgress((int)(overallProgress.Progress * 100), 
     87                    S._("Compressing Report {0}: {1:#0.00%}", reports[i].Name, 0)); 
    9288 
    93                     uploader.Compress(delegate(object from, EraserProgressChangedEventArgs e2) 
    94                         { 
    95                             step.Completed = (int)(e2.Progress.Progress * step.Total); 
    96                             UploadWorker.ReportProgress((int)(progress.Progress * 100), 
     89                uploader.Submit(delegate(object from, EraserProgressChangedEventArgs e2) 
     90                    { 
     91                        reportProgress.Completed = (int)(e2.Progress.Progress * reportProgress.Total); 
     92                        SteppedProgressManager reportSteps = (SteppedProgressManager)e2.Progress; 
     93                        int step = reportSteps.Steps.IndexOf(reportSteps.CurrentStep); 
     94 
     95                        UploadWorker.ReportProgress((int)overallProgress.Progress, 
     96                            step == 0 ?  
    9797                                S._("Compressing Report {0}: {1:#0.00%}", 
    98                                     reports[i].Name, e2.Progress.Progress)); 
     98                                    reports[i].Name, reportSteps.Progress) : 
     99                                S._("Uploading Report {0}: {1:#0.00%}", 
     100                                    reports[i].Name, reportSteps.Progress)); 
    99101 
    100                             if (UploadWorker.CancellationPending) 
    101                                 throw new OperationCanceledException(); 
    102                         }); 
    103                 } 
    104                 { 
    105                     //Upload the report. 
    106                     ProgressManager step = new ProgressManager(); 
    107                     step.Total = 1000; 
    108                     reportProgress.Steps.Add(new SteppedProgressManagerStep(step, 0.5f)); 
    109                     UploadWorker.ReportProgress((int)(progress.Progress * 100), 
    110                         S._("Uploading Report {0}: {1}%", reports[i].Name, 0)); 
    111  
    112                     uploader.Upload(delegate(object from, EraserProgressChangedEventArgs e2) 
    113                         { 
    114                             step.Completed = (int)(e2.Progress.Progress * step.Total); 
    115                             UploadWorker.ReportProgress((int)progress.Progress, 
    116                                 S._("Uploading Report {0}: {1:#0.00%}", 
    117                                     reports[i].Name, e2.Progress.Progress)); 
    118  
    119                             if (UploadWorker.CancellationPending) 
    120                                 throw new OperationCanceledException(); 
    121                         }); 
    122                 } 
     102                        if (UploadWorker.CancellationPending) 
     103                            throw new OperationCanceledException(); 
     104                    }); 
    123105            } 
    124106        } 
     
    127109        { 
    128110            if (e.UserState != null) 
    129                 ProgressLbl.Text = e.UserState as string; 
     111                ProgressLbl.Text = (string)e.UserState; 
    130112            ProgressPb.Value = e.ProgressPercentage; 
    131113        } 
Note: See TracChangeset for help on using the changeset viewer.