Thrown when the graph can not be closed due to an unknown reason.
963232
public static TransactionException closingFailed(TransactionOLTP tx, Exception e) {
        return new TransactionException(CLOSE_FAILURE.getMessage(tx.keyspace()), e);
    }
1285637
private void closeOutboundInternal() {

        if ((debug != null) && Debug.isOn("ssl")) {
            System.out.println(threadName() + ", closeOutboundInternal()");
        }

        /*
         * Already closed, ignore
         */
        if (writer.isOutboundDone()) {
            return;
        }

        switch (connectionState) {

        /*
         * If we haven't even started yet, don't bother reading inbound.
         */
        case cs_START:
            writer.closeOutbound();
            inboundDone = true;
            break;

        case cs_ERROR:
        case cs_CLOSED:
            break;

        /*
         * Otherwise we indicate clean termination.
         */
        // case cs_HANDSHAKE:
        // case cs_DATA:
        // case cs_RENEGOTIATE:
        default:
            warning(Alerts.alert_close_notify);
            writer.closeOutbound();
            break;
        }

        // See comment in changeReadCiphers()
        writeCipher.dispose();

        connectionState = cs_CLOSED;
    }
1115931
final protected RuntimeException runtimeXIfNotClosed(RuntimeException runtimeX) throws SQLException 
    {
        if (state == State.CLOSED)
            throw createClosedException("ResultSet"); 

        return runtimeX;
    }
331162
public synchronized boolean sendError(Throwable cause) {
		if (cause == null) {
			throw new IllegalArgumentException("Unable to send \"null\" as Exception!");
		}
		if (closed.compareAndSet(false, true)) {
			this.cause = cause;
			if (listeners != null) {
				try {
					if (listeners.length == 1) {
						listeners[0].onPacket(null, cause, true);
					} else {
						for (PacketListener listener : listeners) {
							listener.onPacket(null, cause, true);
						}
					}
				} catch (MoleculerError moleculerError) {
					throw moleculerError;
				} catch (Throwable error) {
					throw new MoleculerClientError("Unable to send error to stream listener!", error, nodeID, null);
				}
			}
			return true;
		}
		return false;
	}
818996
private void sanityCheck(
      String seriesName,
      List<?> xData,
      List<? extends Number> yData,
      List<? extends Number> errorBars) {

    if (seriesMap.keySet().contains(seriesName)) {
      throw new IllegalArgumentException(
          "Series name >"
              + seriesName
              + "< has already been used. Use unique names for each series!!!");
    }
    if (yData == null) {
      throw new IllegalArgumentException("Y-Axis data cannot be null!!!");
    }
    if (yData.size() == 0) {
      throw new IllegalArgumentException("Y-Axis data cannot be empty!!!");
    }
    if (xData != null && xData.size() == 0) {
      throw new IllegalArgumentException("X-Axis data cannot be empty!!!");
    }
    if (errorBars != null && errorBars.size() != yData.size()) {
      throw new IllegalArgumentException("Error bars and Y-Axis sizes are not the same!!!");
    }
  }
473053
def is_closed(self):
        
        closed = all(i == 2 for i in
                     dict(self.vertex_graph.degree()).values())

        return closed
627489
private void impossibleOffsetFailed(T object, ObjectId objectId, Cleaners.Cleanable cleanable, ObjectLeakNotifier notifier)
  {
    poolSize.decrementAndGet();
    notifier.disable();
    // Effectively does nothing, because notifier is disabled above. The purpose of this call is to deregister the
    // cleaner from the internal global linked list of all cleaners in the JVM, and let it be reclaimed itself.
    cleanable.clean();
    log.error(
        new ISE("Queue offer failed"),
        "Could not offer object [%s] back into the queue, objectId [%s]",
        object,
        objectId
    );
  }
1039842
private void failOutstandingRequests(Throwable cause) {
    for (Map.Entry<StreamChunkId, ChunkReceivedCallback> entry : outstandingFetches.entrySet()) {
      try {
        entry.getValue().onFailure(entry.getKey().chunkIndex, cause);
      } catch (Exception e) {
        logger.warn("ChunkReceivedCallback.onFailure throws exception", e);
      }
    }
    for (Map.Entry<Long, RpcResponseCallback> entry : outstandingRpcs.entrySet()) {
      try {
        entry.getValue().onFailure(cause);
      } catch (Exception e) {
        logger.warn("RpcResponseCallback.onFailure throws exception", e);
      }
    }
    for (Pair<String, StreamCallback> entry : streamCallbacks) {
      try {
        entry.getValue().onFailure(entry.getKey(), cause);
      } catch (Exception e) {
        logger.warn("StreamCallback.onFailure throws exception", e);
      }
    }

    // It's OK if new fetches appear, as they will fail immediately.
    outstandingFetches.clear();
    outstandingRpcs.clear();
    streamCallbacks.clear();
  }
897237
def connectionLost(self, reason=connectionDone):
        
        self._failed = reason
        pending, self._pending = self._pending, None
        for d in pending.values():
            d.errback(reason)
203641
private synchronized void handleUnavailableException(UnavailableException e, boolean isInit) throws UnavailableException
	 {
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) // 306998.15
            logger.entering(CLASS_NAME, "handleUnavailableException", e); // 569469
        // logger.logp(Level.FINE, CLASS_NAME,"handleUnavailableException", "",
        // e);
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) // 306998.15
            logger.logp(Level.FINE, CLASS_NAME, "handleUnavailableException", "UnavailableException was thrown by servlet: " + getServletName()
                    + " reason:" + e.getMessage());
        if (state == UNAVAILABLE_PERMANENTLY_STATE) {
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) // 306998.15
                logger.exiting(CLASS_NAME, "handleUnavailableException", "state is already permanently unavailable, throw ue"); // 569469
            // logger.logp(Level.FINE, CLASS_NAME,"handleUnavailableException",
            // "state is already permanently unavailable, throw ue");
            throw new UnavailableException(unavailableMessage);
        } else if (e.isPermanent()) {
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) // 306998.15
                logger.logp(Level.FINE, CLASS_NAME, "handleUnavailableException", "exception is permanent");
            if (state == AVAILABLE_STATE) {
                if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) // 306998.15
                    logger.logp(Level.FINE, CLASS_NAME, "handleUnavailableException", "state is available so destroy the servlet");
                /*
                 * This means the UnavailableException is thrown from the
                 * service method so we should destroy this servlet.
                 */
                // destroy();
                // destroy does not remove from the requestMapper which can lead
                // to a 500 error code on a subsequent request
                if (!context.removeServlet(getServletName()))
                    ;
                {
                    // In the case that there are no servlet mappings, we still
                    // need to destroy
                    if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) // 306998.15
                        logger.logp(Level.FINE, CLASS_NAME, "handleUnavailableException",
                                "removeServlet didn't destroy. destroy from handleUnavailableException");
                    destroy();
                }
            }
            unavailableMessage = e.getMessage();
            if(isInit){											
				this.setUninitialize();  // PM01373
			}
			else{				
            setUnavailable();
			}
        } else {
            int secs = e.getUnavailableSeconds();
            if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) // 306998.15
                logger.logp(Level.FINE, CLASS_NAME, "handleUnavailableException", "ue is not permanent, unavailable secs -->[" + secs + "]");
            if (secs > 0) {
                long time = System.currentTimeMillis() + ((secs) * 1000);
                if (time > unavailableUntil) {
                    unavailableMessage = e.getMessage();
                    // only set the time if the new time is farther away than
                    // the old time.
                    setUnavailableUntil(time, isInit);		//PM01373
                }
            }
        }
        if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE)) // 306998.15
            logger.exiting(CLASS_NAME, "handleUnavailableException"); // 569469
    }
1152437
def close(self):
        """"""
        self._state = 'closed'
        self.grid.graph.add_edge(
            self._nodes[0], self._nodes[1], {'line': self._line})
283191
@Override
    public void close() {
        // Check for previous closed.
        if (!closed) {
            try {
                if (resultSet != null) {
                    resultSet.close();
                }
            } catch (final Exception e) {
                logger.warn("Could not close result set.", e);
            }
            if (statementCloseable && statement != null) {
                try {
                    statement.close();
                } catch (final Exception e) {
                    logger.warn("Could not close statement.", e);
                }
            }
        }
        // Assume closed even if it fails.
        closed = true;
    }
1315114
void handleFailureOf(final Supervised supervised) {
    supervised.suspend();
    supervised.supervisor().inform(supervised.throwable(), supervised);
  }
402612
void reportBoundError(UndetVar uv, InferenceBound ib) {
        reportInferenceError(
                String.format("incompatible.%s.bounds", StringUtils.toLowerCase(ib.name())),
                uv.qtype,
                uv.getBounds(ib));
    }
19400
private void handleJobMasterError(final Throwable cause) {
		if (ExceptionUtils.isJvmFatalError(cause)) {
			log.error("Fatal error occurred on JobManager.", cause);
			// The fatal error handler implementation should make sure that this call is non-blocking
			fatalErrorHandler.onFatalError(cause);
		} else {
			jobCompletionActions.jobMasterFailed(cause);
		}
	}
1010029
public synchronized void onRequestFailed(Throwable reason) {
		allRequestsTracker.onRequestFailed(reason);
		recentRequestsTracker.onRequestFailed(reason);
		meter.mark();
	}
400365
public void handleRetry(Throwable cause) {
    try {
      this.retryPolicy.retry(connectionState, retryHandler, connectionFailHandler);
    } catch (RetryPolicy.RetryCancelled retryCancelled) {
      this.getNettyPromise().setFailure(cause);
    }
  }