Stops timer and logs connection information
437816
public function stopConnection()
    {
        $this->connections[$this->counterConnections]['time'] = (time() + microtime(true) - $this->timer);
        $this->counterConnections++;
        $this->timer = 0;
    }
1309469
public void stop_logging () {
   		Vector dl = Util.instance().get_device_list("*");
        for (Object aDl : dl) {
            ((DeviceImpl) aDl).stop_logging();
        }
    }
782942
async def stop(self):
        

        if self._connection_task is None:
            return

        try:
            await self._connection_task.stop()
        finally:
            self._con = None
            self._connection_task = None
            self._manager.clear()
1115920
def handle_quit(self, connection, event):
        
        nickname = self.get_nickname(event)
        self.quit[nickname] = datetime.now()
        del self.joined[nickname]
505106
function onDisconnect() {
	var rids = Object.keys( cache ),
		len = rids.length,
		i;

	// TODO: log
	console.log( process.pid, 'disconnected' );

	// Abort any pending requests...
	for ( i = 0; i < len; i++ ) {
		cache[ rids[i] ].abort();

		// TODO: log
		console.log( process.pid, 'aborting request: ', rids[ i ] );
	}
}
1048006
def stop(self):
		
		if WAppsGlobals.log is not None and WLogApp.__log_handler__ is not None:
			WAppsGlobals.log.removeHandler(WLogApp.__log_handler__)

		WLogApp.__log_handler__ = None
		WAppsGlobals.log = None
956794
def stop(self, timeout=None):
        
        if not timeout:
            timeout = self.timeout
        os.killpg(os.getpgid(self.process.pid), signal.SIGTERM)
        self.thread.join(timeout)
        if self.stopped:
            logging.info("OpenVPN stopped")
            if self in OpenVPN.connected_instances:
                OpenVPN.connected_instances.remove(self)
        else:
            logging.error("Cannot stop OpenVPN!")
            for line in self.notifications.split('\n'):
                logging.warn("OpenVPN output:\t\t%s" % line)
866906
def stop(self):
        """"""
        if self._timer:
            self._timer.stop()
            self._timer.deleteLater()
1091676
def stop(self):
        

        instance_status = Instance.InstanceStatus(status='Terminated')
        xml_content = instance_status.serialize()

        headers = {'Content-Type': 'application/xml'}
        self._client.put(self.resource(), xml_content, headers=headers)
1232263
def stop(self):
        """"""
        if not self._dead:
            self._killed = True
            self._cancelled.set()
            self._busy_sem.release()
            self.join()
            if not self._ready_sem.acquire(False):
                warning("ISOTP Timer thread may not have stopped "
                        "correctly")
487701
public synchronized void stop() {
		LOG.debug("Stopping server on " + port);
		running = false;
		if (handlers != null) {
			for (int i = 0; i < handlerCount; i++) {
				if (handlers[i] != null) {
					handlers[i].interrupt();
				}
			}
		}
		listener.interrupt();
		listener.doStop();
		responder.interrupt();
		notifyAll();

		// Wait until shut down of handlers is complete
		if (this.handlers != null) {

			while (true) {

				int i = 0;
				for (; i < this.handlerCount; i++) {
					if (this.handlers[i] != null) {
						if (!this.handlers[i].isShutDown()) {
							break;
						}
					}
				}

				if (i < this.handlerCount) {
					try {
						wait(100);
					} catch (InterruptedException e) {
						break;
					}
				} else {
					// exit while loop
					break;
				}
			}
		}

		// Wait until shut down of responder is complete
		while (!this.responder.isShutDown()) {
			try {
				wait(100);
			} catch (InterruptedException e) {
				break;
			}
		}

		// Wait until shut down of listener is complete
		while (!this.listener.isShutDown()) {
			try {
				wait(100);
			} catch (InterruptedException e) {
				break;
			}
		}
	}
861253
def stop(opts = {})
      mutex.synchronize do
        check_process!

        log(:debug) { "Stop on #{uri}..." }

        connection.release
        connection.delete if opts[:delete]
        connection.close
        dispatcher.shutdown

        reset
      end
    end
1126703
function () {
			if (winble.deviceManager.isScanning)
				winble.deviceManager.isScanning = false;
			if (winble.deviceManager.connectionWatcher !== null)
				winble.deviceManager.stopConnectionWatcher();
		}
910899
public synchronized void stop() {
		if (timer != null) {
			timer.keepRunning = false;
			timer.interrupt();
			timer = null;
		}
		// Remove this manager from the space alert list
		LogRepositorySpaceAlert.getInstance().removeRepositoryInfo(this);
	}
50918
function clearTimeouts() {
        // stop tracking time for network operations
        self._networkTime = contimer.stop(self._timerCtx, self.buildTimerId('network'));

        if (socketTimeout) {
            clearTimeout(socketTimeout);
            socketTimeout = null;
        }

        if (queueTimeout) {
            clearTimeout(queueTimeout);
            queueTimeout = null;
        }
    }
1028521
def stop(self):
        """"""
        if self.closed:
            raise ConnectionClosed()

        if self.read_watcher.active:
            self.read_watcher.stop()
        if self.write_watcher.active:
            self.write_watcher.stop()
730419
def stop(&callback)
      send_command(:name => :close_connection)
      @stopped_callback = callback
      Log.info("[cook] Disconnecting from agent (#{@pending} response#{@pending > 1 ? 's' : ''} pending)")
      @stop_timeout = EM::Timer.new(STOP_TIMEOUT) do
        Log.warning("[cook] Time out waiting for responses from agent, forcing disconnection")
        @stop_timeout = nil
        on_stopped
      end
      true
    end