Stops this writer and close its output stream.
330926
public synchronized void stop() {
		if (writer != null) {
			try {
				writer.close(headerBytes);
				writer = null;
			} catch (IOException ex) {
				// No need to crash on this error even if the tail won't be written
				// since reading logic can take care of that.
			}
		}
		// Ensure that timer is stopped as well.
		disableFileSwitch();
		
		headerBytes = null;
		// Don't stop manager here since it can be reused for a different repository writer.
		//manager.stop();
	}
1200369
private void stopIn() throws IOException {
    if (inClosed) {
      return;
    }
    inClosed = true;

    LOG.log(Level.FINE, "Shutting down socket for input");

    // unblock all waiting readers
    setEof();

    // signal orchestrator thread it is ok to quit now as there will be no more input
    synchronized (orchestratorEvent) {
      shutdown = true;
      orchestratorEvent.notifyAll();
    }

    // close socket for input - that will cause readExecutor to throw EOFException
    // and exit orchestrator thread main loop; client can still write to the socket
    socket.shutdownInput();
  }
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()
412976
public void close() throws java.io.IOException{
        synchronized(this){
            if(_outHelper.isOutputStream_closed()){
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "output stream close previously completed ...return ");
                }
                return;
            }
            else{
                _outHelper.closeWork();
            }
        }
    }
1368818
def close(self):
        """"""
        self.flush()
        if self._recordio_writer is not None:
            self._recordio_writer.close()
            self._recordio_writer = None
885439
public void close() {
        if (this.m_stream != null) {
            try {
                this.m_stream.close();
                this.m_stream = null;
            } catch (IOException e) {
                logger.warn("Error closing stream", e);
            }
        }
    }
1261043
public void close() throws IOException {
        if (this.debug) {
            System.err.println("TarBuffer.closeBuffer().");
        }

        if (this.outStream != null) {
            this.flushBlock();

            if (this.outStream != System.out && this.outStream != System.err) {
                this.outStream.close();
                this.outStream = null;
            }
        } else if (this.inStream != null) {
            if (this.inStream != System.in) {
                this.inStream.close();
                this.inStream = null;
            }
        }
    }
207193
def close(self):
        
        if self.is_closing():
            return

        self._closing = True
        # make sure the writer wakes up
        self._can_write.set()
1154268
def stop(self):
        
        if self._io_thread is not None:
            self.log.info("Waiting for I/O thread to stop...")
            self.closed = True
            self._io_thread.join()

        if self._writer_thread is not None:
            self.log.info("Waiting for Writer Thread to stop...")
            self.closed = True
            self._writer_thread.join()

        self.log.info("All worker threads stopped.")
1256802
def close(self):
        
        if self._writable and not self._closed:
            self._closed = True
            with self._seek_lock:
                self._flush_raw_or_buffered()
            if self._seek:
                with handle_os_exceptions():
                    self._close_writable()
45293
public void stop() {
        try {
            safeClose(myServerSocket);
            closeAllConnections();
            myThread.join();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
686426
def stop(self):
        

        try:
            # try to properly stop the hypervisor
            yield from self.send("hypervisor stop")
        except UbridgeError:
            pass
        try:
            if self._writer is not None:
                yield from self._writer.drain()
                self._writer.close()
        except OSError as e:
            log.debug("Stopping hypervisor {}:{} {}".format(self._host, self._port, e))
        self._reader = self._writer = None
237961
void close() {
    shuttingDown = true;
    // shutdown thread pools
    dispatcherExecutor.shutdownNow();
    moverExecutor.shutdownNow();
    // close the output file
    IOUtils.closeStream(out);
    if (fs != null) {
      try {
        fs.delete(BALANCER_ID_PATH, true);
      } catch(IOException ignored) {
      }
    }
  }
993555
void closeImpl()
  {
    ReadStreamOld is = _is;
    _is = null;

    WriteStreamOld os = _os;
    _os = null;

    try {
      if (is != null)
        is.close();
    } catch (Throwable e) {
      log.log(Level.FINER, e.toString(), e);
    }

    try {
      if (os != null)
        os.close();
    } catch (Throwable e) {
      log.log(Level.FINER, e.toString(), e);
    }

    if (is != null) {
      _connProbe.end();

      if (_requestStartTime > 0)
        _requestTimeProbe.end(_requestStartTime);

      if (_isIdle)
        _idleProbe.end();
    }
  }
1318128
public void close() {
		clearBuffers();
		// make sure we terminate the thread in any case
		if (outputFlusher.isPresent()) {
			outputFlusher.get().terminate();
			try {
				outputFlusher.get().join();
			} catch (InterruptedException e) {
				// ignore on close
				// restore interrupt flag to fast exit further blocking calls
				Thread.currentThread().interrupt();
			}
		}
	}
1176222
protected synchronized void close() {

        this.closed = true;

        setReadable(false);
        setWritable(false);
        freeOutputStream();
        freeInputStream();

        this.gzdata = null;
    }
597912
public void stop() {
		if (this.writer != null) {
			this.writer.stop();
			this.writer.getLogRepositoryManager().stop();
			this.writer = null;
		}
	}