Callback for uploads stop, equivalent to the global ajaxStop event:
170091
function (e) {
                var that = $(this).data('blueimp-fileupload') ||
                        $(this).data('fileupload'),
                    deferred = that._addFinishedDeferreds();
                $.when.apply($, that._getFinishedDeferreds())
                    .done(function () {
                        that._trigger('stopped', e);
                    });
                that._transition($(this).find('.fileupload-progress')).done(
                    function () {
                        $(this).find('.progress')
                            .attr('aria-valuenow', '0')
                            .find('.bar').css('width', '0%');
                        $(this).find('.progress-extended').html('&nbsp;');
                        deferred.resolve();
                    }
                );
            }
895934
function stop(callback) {
    if (httpServer) {
        DEBUG && debug('stop http server');
        try {
            httpServer.close();
        } catch (e) {
        }
        httpServer = null;
    } else {
        DEBUG && debug('***ignore*** http server is not running!');
    }
    callback && callback(false);
}
967711
async def server_stop(app, loop):
    """"""
    em = Embed(color=0xe67e22)
    em.set_footer('Host: {}'.format(socket.gethostname()))
    em.description = '[INFO] Server Stopped'

    await app.webhook.send(embed=em)
    await app.session.close()
444810
function (error, res) {
            task.uploadError = 'error';
            for (var i = task.uploadingAjax.length - 1; i >= 0; i--) {
                var ajax = task.uploadingAjax[i];
                ajax && ajax.abort();
            }
            task.onTaskProgress(true);
            defer.reject(res);
        }
637616
function() {
      _.each(this.__currentUpdateEvents, function(eventConfig) {
        this.stopListening(eventConfig.model, eventConfig.eventName);
      }, this);
      this.__currentUpdateEvents = [];
    }
841902
function stop () {
    if (this.state === 'inactive') {
      return this.em.dispatchEvent(error('stop'))
    }

    this.requestData()
    this.state = 'inactive'
    this.clone.getTracks().forEach(function (track) {
      track.stop()
    })
    return clearInterval(this.slicing)
  }
702468
function() {
		var i = 0;
		while (i<_callbacks.length) {
			var deps = _callbacks[i][0],
				func = _callbacks[i][1],
				n = 0;
			while (n<deps.length) {
				if (areDeepDepsDefined(deps[n])) {
					deps.splice(n, 1);
				}
				else {
					n++;
				}
			}
			if (!deps.length) {
				_callbacks.splice(i, 1);
				if (func != null) {
					setTimeout(func, 0);
				}
			}
			else {
				i++;
			}
		}
	}
105775
function onBeforeUnloadIE () {
        nativeMethods.setTimeout.call(window, function () {
            //NOTE: except file downloading
            if (document.readyState === 'loading' &&
                !(document.activeElement && domUtils.isAnchorElement(document.activeElement) &&
                document.activeElement.hasAttribute('download')))
                onBeforeUnload();
        }, 0);
    }
696712
function(inXhr) {
		if (inXhr.onload) {
			inXhr.onload = null;
		}
		if (inXhr.onreadystatechange) {
			inXhr.onreadystatechange = null;
		}
		if (inXhr.abort) {
			inXhr.abort();
		}
	}
624921
function () {

                var that = this,
                    paramHandler = this.params.handler,
                    params = util.mixin({}, this.params);

                //wrap the handler callbacks in a cancel check
                function handler(responseCode, data, ioArgs) {
                    that.xhr = ioArgs.xhr;
                    that.statusCode = that.xhr && !that.xhr.timedOut && that.xhr.status || 0;
                    if (that.canceled) {
                        logger.debug("Request [" + that.id + "] was canceled, not calling handler");
                    } else {
                        that.pending = false;
                        that.complete = true;
                        paramHandler(responseCode, data, ioArgs);
                    }
                }

                if (this.canceled) {
                    logger.debug("Request [" + that.id + "] was canceled, not executing");
                } else {
                    this.pending = true;
                    this.fn(util.mixin(params, {
                        handler: handler
                    }));
                }
            }
216901
function startUploadStateCheck(timeout, cb) {
    var checkTimer = null;

    /**
     * 每10ms检测一次uploading状态，当前没有上传任务时，uploading为0
     * @return {[type]} [description]
     */
    function checkUplodingStatus() {
        checkTimer = setInterval(function () {
            if (uploading === 0 && checkTimer) {
                clearInterval(checkTimer);
                checkTimer = null;
                // 检测通过，开始检测50ms内是否还有新请求
                waitforNewUpload();
            }
        }, 10);
    }

    /**
     * 判断20ms内是否还有新增的上传请求，如果有则回到uploding检测状态
     * @return {[type]} [description]
     */
    function waitforNewUpload() {
        var periodTotal = total;
        setTimeout(function () {
            if (periodTotal === total) {
                debuglog('detect upload end');
                end();
            }
            else {
                debuglog('restart upload detect', periodTotal, total);
                checkUplodingStatus(cb);
            }
        }, 50);
    }

    function end() {
        globalCheckSatus = false;
        clearTimeout(uploadTimeout);
        uploadTimeout = null;
        clearInterval(checkTimer);
        checkTimer = null;
        total = 0;
        cb && cb();
    }

    if (globalCheckSatus) {
        return;
    }

    globalCheckSatus = true;

    checkUplodingStatus();

    // 上传整体超时检测
    var uploadTimeout = setTimeout(function () {
        debuglog('upload timeout');
        end();
    }, timeout * 1000);
}
980415
function stop(options, callback) {
  const args = utils.getArgs(options, [config], callback);
  const url = `http://${args.options.ip}:${args.options.port}/stop`;

  return request.get(url, function(err) {
    if (err && err.code !== "ECONNREFUSED") {
      return args.callback(err);
    }
    return args.callback(null);
  });
}
521814
@Handler(priority = -1000)
    public void onStop(Stop event) {
        if (closing || !serverSocketChannel.isOpen()) {
            return;
        }
        newSyncEventPipeline().fire(new Close(), this);
    }
1340067
def stop():
    
    global global_server
    if global_server is not None:
        ioloop = global_server.ioloop
        def stop_ioloop():
            ioloop.stop()
            ioloop.close()
        global_server.ioloop.add_callback(stop_ioloop)
        global_server = None
136596
def termination_check(self):
        # type: (Uploader) -> bool
        
        with self._upload_lock:
            with self._transfer_lock:
                return (self._upload_terminate or
                        len(self._exceptions) > 0 or
                        (self._all_files_processed and
                         len(self._upload_set) == 0 and
                         len(self._transfer_set) == 0))
821055
function() {
            var xhr = $.ajaxSettings.xhr();
            if (!xhr.upload) return xhr;
            xhr.upload.addEventListener('progress', function(e) {
              options.progress(e.loaded / e.total);
            });
            return xhr;
          }
941835
function() {
            if (!api._) {
              completion(new $.Error('The plugin went away before the stream could be bound.'));
              return;
            }

            if (api._.videoWidth > 0) {
              // This fires a little too soon.
              setTimeout(completion, 200);
            }
            else {
              setTimeout(verifyStream, 500);
            }
          }