[Summary view] [Print] [Text view]

   1  YUI.add('moodle-core-checknet', function (Y, NAME) {
   2  
   3  // This file is part of Moodle - http://moodle.org/
   4  //
   5  // Moodle is free software: you can redistribute it and/or modify
   6  // it under the terms of the GNU General Public License as published by
   7  // the Free Software Foundation, either version 3 of the License, or
   8  // (at your option) any later version.
   9  //
  10  // Moodle is distributed in the hope that it will be useful,
  11  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  // GNU General Public License for more details.
  14  //
  15  // You should have received a copy of the GNU General Public License
  16  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  17  
  18  /**
  19   * A utility to check whether the connection to the Moodle server is still
  20   * active.
  21   *
  22   * @module     moodle-core-checknet
  23   * @package    core
  24   * @copyright  2014 Andrew Nicols <andrew@nicols.co.uk>
  25   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  26   * @main       moodle-core-checknet
  27   */
  28  
  29  /**
  30   * @namespace M.core
  31   * @class checknet
  32   */
  33  
  34  function CheckNet() {
  35      CheckNet.superclass.constructor.apply(this, arguments);
  36  }
  37  
  38  Y.extend(CheckNet, Y.Base, {
  39      /**
  40       * A link to the warning dialogue.
  41       *
  42       * @property _alertDialogue
  43       * @type M.core.dialogue
  44       * @private
  45       * @default null
  46       */
  47      _alertDialogue: null,
  48  
  49      /**
  50       * Setup the checking mechanism.
  51       *
  52       * @method initializer
  53       */
  54      initializer: function() {
  55          // Perform our first check.
  56          this._scheduleCheck();
  57      },
  58  
  59      /**
  60       * Schedule a check of the checknet file.
  61       *
  62       * @method _scheduleCheck
  63       * @chainable
  64       * @private
  65       */
  66      _scheduleCheck: function() {
  67          // Schedule the next check after five seconds.
  68          Y.later(this.get('frequency'), this, this._performCheck);
  69  
  70          return this;
  71      },
  72  
  73      /**
  74       * Perform an immediate check of the checknet file.
  75       *
  76       * @method _performCheck
  77       * @private
  78       */
  79      _performCheck: function() {
  80          Y.io(this.get('uri'), {
  81              data: {
  82                  // Add the session key.
  83                  sesskey: M.cfg.sesskey,
  84                  // Add a query string to prevent older versions of IE from using the cache.
  85                  time: new Date().getTime()
  86              },
  87              timeout: this.get('timeout'),
  88              headers: {
  89                  'Cache-Control': 'no-cache',
  90                  'Expires': '-1'
  91              },
  92              context: this,
  93              on: {
  94                  complete: function(tid, response) {
  95                      // Check for failure conditions.
  96                      // We check for a valid status here because if the user is moving away from the page at the time we
  97                      // run this callback we do not want to display the error.
  98                      if (response && typeof response.status !== "undefined") {
  99                          var code = parseInt(response.status, 10);
 100  
 101                          if (code === 200) {
 102                              // This is a valid attempt - clear any existing warning dialogue and destroy it.
 103                              if (this._alertDialogue) {
 104                                  this._alertDialogue.destroy();
 105                                  this._alertDialogue = null;
 106                              }
 107                          } else if (code >= 300 && code <= 399) {
 108                              // This is a cached status - warn developers, but otherwise ignore.
 109                              Y.log("A cached copy of the checknet status file was returned so it's reliablity cannot be guaranteed",
 110                                  'warn',
 111                                  'moodle-mod_scorm-checknet');
 112                          } else {
 113                              if (this._alertDialogue === null || this._alertDialogue.get('destroyed')) {
 114                                  // Only create a new dialogue if it isn't already displayed.
 115                                  this._alertDialogue = new M.core.alert({
 116                                      message: M.util.get_string.apply(this, this.get('message'))
 117                                  });
 118                              } else {
 119                                  this._alertDialogue.show();
 120                              }
 121                          }
 122                      }
 123  
 124                      // Start the next check.
 125                      this._scheduleCheck();
 126                  }
 127              }
 128          });
 129      }
 130  }, {
 131      NAME: 'checkNet',
 132      ATTRS: {
 133          /**
 134           * The file to check access against.
 135           *
 136           * @attribute uri
 137           * @type String
 138           * @default M.cfg.wwwroot + '/lib/yui/build/moodle-core-checknet/assets/checknet.txt'
 139           */
 140          uri: {
 141              value: M.cfg.wwwroot + '/lib/yui/build/moodle-core-checknet/assets/checknet.txt'
 142          },
 143  
 144          /**
 145           * The timeout (in milliseconds) before the checker should give up and display a warning.
 146           *
 147           * @attribute timeout
 148           * @type Number
 149           * @value 4000
 150           */
 151          timeout: {
 152              value: 4000
 153          },
 154  
 155          /**
 156           * The frequency (in milliseconds) that checks should be run.
 157           * A new check is not begun until the previous check has completed.
 158           *
 159           * @attribute frequency
 160           * @writeOnce
 161           * @type Number
 162           * @value 10000
 163           */
 164          frequency: {
 165              value: 10000
 166          },
 167  
 168          /**
 169           * The message which should be displayed upon a test failure.
 170           *
 171           * The array values are passed directly to M.util.get_string() and arguments should match accordingly.
 172           *
 173           * @attribute message
 174           * @type Array
 175           * @value [
 176           *  'networkdropped',
 177           *  'moodle'
 178           * ]
 179           */
 180          message: {
 181              value: [
 182                  'networkdropped',
 183                  'moodle'
 184              ]
 185          }
 186      }
 187  });
 188  
 189  M.core = M.core || {};
 190  M.core.checknet = M.core.checknet || {};
 191  M.core.checknet.init = function(config) {
 192      return new CheckNet(config);
 193  };
 194  
 195  
 196  }, '@VERSION@', {"requires": ["base-base", "moodle-core-notification-alert", "io-base"]});