Stops the endpoint.
974952
public void stop() {
		
		try {
			if (this.socket != null) {
				this.socket.close();
			}
		} catch (final IOException e1) {
			GPSdEndpoint.LOG.debug("Close forced: " + e1.getMessage());
		}
		
		this.listeners.clear();
		
		if (this.listenThread != null) {
			this.listenThread.halt();
		}
		
		this.listenThread = null;
	}
1315961
def stop(self):
    
    with self.lock:
      self.halting = True
      self.go.clear()
590212
public void stop()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "stop");
      
    // Lock exclusively for start operations
    mpioLockManager.lockExclusive();
    started = false;
    mpioLockManager.unlockExclusive();
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "stop"); 
  }
714040
public synchronized void stop() {
        if (isRunning()) {
            try {
                setSendingStatus(false);
            } catch (Throwable t) {
                logger.error("Problem stopping sending status during shutdown", t);
            }
            DeviceFinder.getInstance().removeIgnoredAddress(socket.get().getLocalAddress());
            socket.get().close();
            socket.set(null);
            broadcastAddress.set(null);
            updates.clear();
            setTempoMaster(null);
            setDeviceNumber((byte)0);  // Set up for self-assignment if restarted.
            deliverLifecycleAnnouncement(logger, false);
        }
    }
954533
def stop(self):
        '''
        
        '''
        assert(self.model)
        assert(self.user_interface)
        assert(self.target)
        self.user_interface.stop()
        self.target.teardown()
        self.dataman.submit_task(None)
        self._un_set_signal_handler()
799178
def stop(self):
        """"""
        if self._progressing:
            self._progressing = False
            self._thread.join()
639183
def stop(self):
        """"""
        args = self.getShutdownArgs() + ['shutdown']
        Pyro.nsc.main(args)
        self.join()
375094
def terminate(self):
        """"""
        self._backend_client.clear()
        self._needs_save = False
        self._started = False
        self._expire_cookie = True
        self._send_cookie = True
633669
public void disconnectEnd() {
		if (this.endPoint != null) {
			this.endPoint.remove(this);
		}
		this.endPoint = new SGraphPoint(getGraph());
		this.endPoint.add(this);
	}
24784
public void stop() {

    reflector.stop();
    reflectorFuture.cancel(true);
    reflectExecutor.shutdown();

    if (resyncFuture != null) {
      resyncFuture.cancel(true);
      resyncExecutor.shutdown();
    }
  }
1285635
public void stop() {
		if (LOG.isInfoEnabled()) {
			LOG.info("Esper statement [" + epl + "] being stopped");
		}

		this.epStatement.stop();

		if (LOG.isInfoEnabled()) {
			LOG.info("Esper statement [" + epl + "] stopped");
		}
	}
13902
def stop(self):
        """"""
        if self._outstanding:
            _LOGGER.warning('There were %d outstanding requests',
                            len(self._outstanding))

        self._initial_message_sent = False
        self._outstanding = {}
        self._one_shots = {}
        self.connection.close()
436541
async def stop(self):
        """"""

        if self._rpc_task is not None:
            self._rpc_task.cancel()

        try:
            await self._rpc_task
        except asyncio.CancelledError:
            pass

        self._rpc_task = None
1035407
def stop_server(self):
        
        self.stop = True
        while self.task_count:
            time.sleep(END_RESP)
        self.terminate = True
1218544
def stop(self):
        
        if self._wrapper_telnet_server:
            self._wrapper_telnet_server.close()
            yield from self._wrapper_telnet_server.wait_closed()
        self.status = "stopped"
1117543
public void stop() {
        CompletableFuture.runAsync(() -> {
            try {
                bootstrap.getInjector().getInstance(Server.class).stop();
            } catch (Exception ignore) {
                // Ignore NPE. At this point the server REALLY should be possible to find
            }
            bootstrap.shutdown();
        });
    }
266000
def stop(self):
        
        self.my_server.stop()
        self.http_thread.join()
        logging.info("HTTP server: Stopped")