[Summary view] [Print] [Text view]

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