source: trunk/web/addons/job_monarch/lib/extjs-30/examples/image-organizer/SWFUpload/plugins/swfupload.speed.js @ 625

Last change on this file since 625 was 625, checked in by ramonb, 15 years ago

lib/extjs-30:

  • new ExtJS 3.0
File size: 12.4 KB
Line 
1/*!
2 * Ext JS Library 3.0.0
3 * Copyright(c) 2006-2009 Ext JS, LLC
4 * licensing@extjs.com
5 * http://www.extjs.com/license
6 */
7/*
8        Speed Plug-in
9       
10        Features:
11                *Adds several properties to the 'file' object indicated upload speed, time left, upload time, etc.
12                        - currentSpeed -- String indicating the upload speed, bytes per second
13                        - averageSpeed -- Overall average upload speed, bytes per second
14                        - movingAverageSpeed -- Speed over averaged over the last several measurements, bytes per second
15                        - timeRemaining -- Estimated remaining upload time in seconds
16                        - timeElapsed -- Number of seconds passed for this upload
17                        - percentUploaded -- Percentage of the file uploaded (0 to 100)
18                        - sizeUploaded -- Formatted size uploaded so far, bytes
19               
20                *Adds setting 'moving_average_history_size' for defining the window size used to calculate the moving average speed.
21               
22                *Adds several Formatting functions for formatting that values provided on the file object.
23                        - SWFUpload.speed.formatBPS(bps) -- outputs string formatted in the best units (Gbps, Mbps, Kbps, bps)
24                        - SWFUpload.speed.formatTime(seconds) -- outputs string formatted in the best units (x Hr y M z S)
25                        - SWFUpload.speed.formatSize(bytes) -- outputs string formatted in the best units (w GB x MB y KB z B )
26                        - SWFUpload.speed.formatPercent(percent) -- outputs string formatted with a percent sign (x.xx %)
27                        - SWFUpload.speed.formatUnits(baseNumber, divisionArray, unitLabelArray, fractionalBoolean)
28                                - Formats a number using the division array to determine how to apply the labels in the Label Array
29                                - factionalBoolean indicates whether the number should be returned as a single fractional number with a unit (speed)
30                                    or as several numbers labeled with units (time)
31        */
32
33var SWFUpload;
34if (typeof(SWFUpload) === "function") {
35        SWFUpload.speed = {};
36       
37        SWFUpload.prototype.initSettings = (function (oldInitSettings) {
38                return function () {
39                        if (typeof(oldInitSettings) === "function") {
40                                oldInitSettings.call(this);
41                        }
42                       
43                        this.ensureDefault = function (settingName, defaultValue) {
44                                this.settings[settingName] = (this.settings[settingName] == undefined) ? defaultValue : this.settings[settingName];
45                        };
46
47                        // List used to keep the speed stats for the files we are tracking
48                        this.fileSpeedStats = {};
49                        this.speedSettings = {};
50
51                        this.ensureDefault("moving_average_history_size", "10");
52                       
53                        this.speedSettings.user_file_queued_handler = this.settings.file_queued_handler;
54                        this.speedSettings.user_file_queue_error_handler = this.settings.file_queue_error_handler;
55                        this.speedSettings.user_upload_start_handler = this.settings.upload_start_handler;
56                        this.speedSettings.user_upload_error_handler = this.settings.upload_error_handler;
57                        this.speedSettings.user_upload_progress_handler = this.settings.upload_progress_handler;
58                        this.speedSettings.user_upload_success_handler = this.settings.upload_success_handler;
59                        this.speedSettings.user_upload_complete_handler = this.settings.upload_complete_handler;
60                       
61                        this.settings.file_queued_handler = SWFUpload.speed.fileQueuedHandler;
62                        this.settings.file_queue_error_handler = SWFUpload.speed.fileQueueErrorHandler;
63                        this.settings.upload_start_handler = SWFUpload.speed.uploadStartHandler;
64                        this.settings.upload_error_handler = SWFUpload.speed.uploadErrorHandler;
65                        this.settings.upload_progress_handler = SWFUpload.speed.uploadProgressHandler;
66                        this.settings.upload_success_handler = SWFUpload.speed.uploadSuccessHandler;
67                        this.settings.upload_complete_handler = SWFUpload.speed.uploadCompleteHandler;
68                       
69                        delete this.ensureDefault;
70                };
71        })(SWFUpload.prototype.initSettings);
72
73       
74        SWFUpload.speed.fileQueuedHandler = function (file) {
75                if (typeof this.speedSettings.user_file_queued_handler === "function") {
76                        file = SWFUpload.speed.extendFile(file);
77                       
78                        return this.speedSettings.user_file_queued_handler.call(this, file);
79                }
80        };
81       
82        SWFUpload.speed.fileQueueErrorHandler = function (file, errorCode, message) {
83                if (typeof this.speedSettings.user_file_queue_error_handler === "function") {
84                        file = SWFUpload.speed.extendFile(file);
85                       
86                        return this.speedSettings.user_file_queue_error_handler.call(this, file, errorCode, message);
87                }
88        };
89
90        SWFUpload.speed.uploadStartHandler = function (file) {
91                if (typeof this.speedSettings.user_upload_start_handler === "function") {
92                        file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
93                        return this.speedSettings.user_upload_start_handler.call(this, file);
94                }
95        };
96       
97        SWFUpload.speed.uploadErrorHandler = function (file, errorCode, message) {
98                file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
99                SWFUpload.speed.removeTracking(file, this.fileSpeedStats);
100
101                if (typeof this.speedSettings.user_upload_error_handler === "function") {
102                        return this.speedSettings.user_upload_error_handler.call(this, file, errorCode, message);
103                }
104        };
105        SWFUpload.speed.uploadProgressHandler = function (file, bytesComplete, bytesTotal) {
106                this.updateTracking(file, bytesComplete);
107                file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
108
109                if (typeof this.speedSettings.user_upload_progress_handler === "function") {
110                        return this.speedSettings.user_upload_progress_handler.call(this, file, bytesComplete, bytesTotal);
111                }
112        };
113       
114        SWFUpload.speed.uploadSuccessHandler = function (file, serverData) {
115                if (typeof this.speedSettings.user_upload_success_handler === "function") {
116                        file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
117                        return this.speedSettings.user_upload_success_handler.call(this, file, serverData);
118                }
119        };
120        SWFUpload.speed.uploadCompleteHandler = function (file) {
121                file = SWFUpload.speed.extendFile(file, this.fileSpeedStats);
122                SWFUpload.speed.removeTracking(file, this.fileSpeedStats);
123
124                if (typeof this.speedSettings.user_upload_complete_handler === "function") {
125                        return this.speedSettings.user_upload_complete_handler.call(this, file);
126                }
127        };
128       
129        // Private: extends the file object with the speed plugin values
130        SWFUpload.speed.extendFile = function (file, trackingList) {
131                var tracking;
132               
133                if (trackingList) {
134                        tracking = trackingList[file.id];
135                }
136               
137                if (tracking) {
138                        file.currentSpeed = tracking.currentSpeed;
139                        file.averageSpeed = tracking.averageSpeed;
140                        file.movingAverageSpeed = tracking.movingAverageSpeed;
141                        file.timeRemaining = tracking.timeRemaining;
142                        file.timeElapsed = tracking.timeElapsed;
143                        file.percentUploaded = tracking.percentUploaded;
144                        file.sizeUploaded = tracking.bytesUploaded;
145
146                } else {
147                        file.currentSpeed = 0;
148                        file.averageSpeed = 0;
149                        file.movingAverageSpeed = 0;
150                        file.timeRemaining = 0;
151                        file.timeElapsed = 0;
152                        file.percentUploaded = 0;
153                        file.sizeUploaded = 0;
154                }
155               
156                return file;
157        };
158       
159        // Private: Updates the speed tracking object, or creates it if necessary
160        SWFUpload.prototype.updateTracking = function (file, bytesUploaded) {
161                var tracking = this.fileSpeedStats[file.id];
162                if (!tracking) {
163                        this.fileSpeedStats[file.id] = tracking = {};
164                }
165               
166                // Sanity check inputs
167                bytesUploaded = bytesUploaded || tracking.bytesUploaded || 0;
168                if (bytesUploaded < 0) {
169                        bytesUploaded = 0;
170                }
171                if (bytesUploaded > file.size) {
172                        bytesUploaded = file.size;
173                }
174               
175                var tickTime = (new Date()).getTime();
176                if (!tracking.startTime) {
177                        tracking.startTime = (new Date()).getTime();
178                        tracking.lastTime = tracking.startTime;
179                        tracking.currentSpeed = 0;
180                        tracking.averageSpeed = 0;
181                        tracking.movingAverageSpeed = 0;
182                        tracking.movingAverageHistory = [];
183                        tracking.timeRemaining = 0;
184                        tracking.timeElapsed = 0;
185                        tracking.percentUploaded = bytesUploaded / file.size;
186                        tracking.bytesUploaded = bytesUploaded;
187                } else if (tracking.startTime > tickTime) {
188                        this.debug("When backwards in time");
189                } else {
190                        // Get time and deltas
191                        var now = (new Date()).getTime();
192                        var lastTime = tracking.lastTime;
193                        var deltaTime = now - lastTime;
194                        var deltaBytes = bytesUploaded - tracking.bytesUploaded;
195                       
196                        if (deltaBytes === 0 || deltaTime === 0) {
197                                return tracking;
198                        }
199                       
200                        // Update tracking object
201                        tracking.lastTime = now;
202                        tracking.bytesUploaded = bytesUploaded;
203                       
204                        // Calculate speeds
205                        tracking.currentSpeed = (deltaBytes * 8 ) / (deltaTime / 1000);
206                        tracking.averageSpeed = (tracking.bytesUploaded * 8) / ((now - tracking.startTime) / 1000);
207
208                        // Calculate moving average
209                        tracking.movingAverageHistory.push(tracking.currentSpeed);
210                        if (tracking.movingAverageHistory.length > this.settings.moving_average_history_size) {
211                                tracking.movingAverageHistory.shift();
212                        }
213                       
214                        tracking.movingAverageSpeed = SWFUpload.speed.calculateMovingAverage(tracking.movingAverageHistory);
215                       
216                        // Update times
217                        tracking.timeRemaining = (file.size - tracking.bytesUploaded) * 8 / tracking.movingAverageSpeed;
218                        tracking.timeElapsed = (now - tracking.startTime) / 1000;
219                       
220                        // Update percent
221                        tracking.percentUploaded = (tracking.bytesUploaded / file.size * 100);
222                }
223               
224                return tracking;
225        };
226        SWFUpload.speed.removeTracking = function (file, trackingList) {
227                try {
228                        trackingList[file.id] = null;
229                        delete trackingList[file.id];
230                } catch (ex) {
231                }
232        };
233       
234        SWFUpload.speed.formatUnits = function (baseNumber, unitDivisors, unitLabels, singleFractional) {
235                var i, unit, unitDivisor, unitLabel;
236
237                if (baseNumber === 0) {
238                        return "0 " + unitLabels[unitLabels.length - 1];
239                }
240               
241                if (singleFractional) {
242                        unit = baseNumber;
243                        unitLabel = unitLabels.length >= unitDivisors.length ? unitLabels[unitDivisors.length - 1] : "";
244                        for (i = 0; i < unitDivisors.length; i++) {
245                                if (baseNumber >= unitDivisors[i]) {
246                                        unit = (baseNumber / unitDivisors[i]).toFixed(2);
247                                        unitLabel = unitLabels.length >= i ? " " + unitLabels[i] : "";
248                                        break;
249                                }
250                        }
251                       
252                        return unit + unitLabel;
253                } else {
254                        var formattedStrings = [];
255                        var remainder = baseNumber;
256                       
257                        for (i = 0; i < unitDivisors.length; i++) {
258                                unitDivisor = unitDivisors[i];
259                                unitLabel = unitLabels.length > i ? " " + unitLabels[i] : "";
260                               
261                                unit = remainder / unitDivisor;
262                                if (i < unitDivisors.length -1) {
263                                        unit = Math.floor(unit);
264                                } else {
265                                        unit = unit.toFixed(2);
266                                }
267                                if (unit > 0) {
268                                        remainder = remainder % unitDivisor;
269                                       
270                                        formattedStrings.push(unit + unitLabel);
271                                }
272                        }
273                       
274                        return formattedStrings.join(" ");
275                }
276        };
277       
278        SWFUpload.speed.formatBPS = function (baseNumber) {
279                var bpsUnits = [1073741824, 1048576, 1024, 1], bpsUnitLabels = ["Gbps", "Mbps", "Kbps", "bps"];
280                return SWFUpload.speed.formatUnits(baseNumber, bpsUnits, bpsUnitLabels, true);
281       
282        };
283        SWFUpload.speed.formatTime = function (baseNumber) {
284                var timeUnits = [86400, 3600, 60, 1], timeUnitLabels = ["d", "h", "m", "s"];
285                return SWFUpload.speed.formatUnits(baseNumber, timeUnits, timeUnitLabels, false);
286       
287        };
288        SWFUpload.speed.formatBytes = function (baseNumber) {
289                var sizeUnits = [1073741824, 1048576, 1024, 1], sizeUnitLabels = ["GB", "MB", "KB", "bytes"];
290                return SWFUpload.speed.formatUnits(baseNumber, sizeUnits, sizeUnitLabels, true);
291       
292        };
293        SWFUpload.speed.formatPercent = function (baseNumber) {
294                return baseNumber.toFixed(2) + " %";
295        };
296       
297        SWFUpload.speed.calculateMovingAverage = function (history) {
298                var vals = [], size, sum = 0.0, mean = 0.0, varianceTemp = 0.0, variance = 0.0, standardDev = 0.0;
299                var i;
300                var mSum = 0, mCount = 0;
301               
302                size = history.length;
303               
304                // Check for sufficient data
305                if (size >= 8) {
306                        // Clone the array and Calculate sum of the values
307                        for (i = 0; i < size; i++) {
308                                vals[i] = history[i];
309                                sum += vals[i];
310                        }
311
312                        mean = sum / size;
313
314                        // Calculate variance for the set
315                        for (i = 0; i < size; i++) {
316                                varianceTemp += Math.pow((vals[i] - mean), 2);
317                        }
318
319                        variance = varianceTemp / size;
320                        standardDev = Math.sqrt(variance);
321                       
322                        //Standardize the Data
323                        for (i = 0; i < size; i++) {
324                                vals[i] = (vals[i] - mean) / standardDev;
325                        }
326
327                        // Calculate the average excluding outliers
328                        var deviationRange = 2.0;
329                        for (i = 0; i < size; i++) {
330                               
331                                if (vals[i] <= deviationRange && vals[i] >= -deviationRange) {
332                                        mCount++;
333                                        mSum += history[i];
334                                }
335                        }
336                       
337                } else {
338                        // Calculate the average (not enough data points to remove outliers)
339                        mCount = size;
340                        for (i = 0; i < size; i++) {
341                                mSum += history[i];
342                        }
343                }
344
345                return mSum / mCount;
346        };
347       
348}
Note: See TracBrowser for help on using the repository browser.