Performs a pre-flight request to ensure the Artifactory service is
reachable.

@return <code>true</code> if Artifactory could be reached; otherwise
<code>false</code>.
510441
public boolean preflightRequest() {
        try {
            final URL url = buildUrl(Checksum.getSHA1Checksum(UUID.randomUUID().toString()));
            final HttpURLConnection connection = connect(url);
            if (connection.getResponseCode() != 200) {
                LOGGER.warn("Expected 200 result from Artifactory ({}), got {}", url, connection.getResponseCode());
                return false;
            }
            return true;
        } catch (IOException e) {
            LOGGER.error("Cannot connect to Artifactory", e);
            return false;
        }

    }
237099
public final boolean awaitUninterruptibly() {
        try {
            return await(15, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        }
    }
35425
public boolean hasNext() throws SISessionUnavailableException, SISessionDroppedException, SIIncorrectCallException
  {
    if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
      SibTr.entry(CoreSPILockedMessageEnumeration.tc, "hasNext", this);
          
    checkValidState("hasNext");
          
    _localConsumerPoint.checkNotClosed();
    
    boolean hasNext = false;
    
    if(!_seenSingleMessage)
    {
      hasNext = true;
    }
    
    if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
      SibTr.exit(CoreSPILockedMessageEnumeration.tc, "hasNext", new Boolean(hasNext));    
      
    return hasNext;
  }
84072
protected boolean isUserRequest()
   {
      if (tc.isEntryEnabled()) SibTr.entry(this, tc, "isUserRequest");
      if (tc.isEntryEnabled()) SibTr.exit(this, tc, "isUserRequest", ""+isUserRequest);
      return isUserRequest;
   }
1321348
boolean isReady() {
        final C[] ds = destinations.get();
        if (ds == null)
            return false;
        for (final C d : ds)
            if (d == null)
                return false;
        final boolean ret = ds.length != 0; // this method is only called in tests and this needs to be true there.

        if (ret && LOGGER.isDebugEnabled())
            LOGGER.debug("at {} to {} is Ready " + shorthand(ds), thisNodeId, groupName);

        return ret;
    }
184728
public boolean isForeignBus()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "isForeignBus");

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "isForeignBus",Boolean.TRUE);

    return true;
  }
645312
private boolean waitForAvailabilityInternal() {
      final Directory directory = indexManager.getDirectoryProvider().getDirectory();
      try {
         Lock lock = directory.obtainLock(IndexWriter.WRITE_LOCK_NAME);
         lock.close();
         return true;
      } catch (LockObtainFailedException lofe) {
         return false;
      } catch (IOException e) {
         log.error(e);
         return false;
      }
   }
1102280
boolean isReady() {
        final ContainerAddress[] ds = destinations.get();
        if (ds == null)
            return false;
        for (final ContainerAddress d : ds)
            if (d == null)
                return false;
        final boolean ret = ds.length != 0; // this method is only called in tests and this needs to be true there.

        if (ret && LOGGER.isDebugEnabled())
            LOGGER.debug("at {} to {} is Ready " + shorthand(ds), thisNodeId, clusterId);

        return ret;
    }
14783
public boolean isReady(final Class serviceClass) {

                Service service = serviceCache.get(serviceClass);
                return (service != null && service.isRunning());
	}
226427
@Override
    public boolean isHAEnabled() {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "isHAEnabled");

        final boolean haEnabled = Configuration.HAEnabled();

        if (tc.isEntryEnabled())
            Tr.exit(tc, "isHAEnabled", haEnabled);
        return haEnabled;
    }
1345742
@Override
    public boolean isAtomServiceURI(final AtomRequest areq) {
        final String[] pathInfo = StringUtils.split(areq.getPathInfo(), "/");
        if (pathInfo.length == 0) {
            return true;
        }
        return false;
    }
1180822
protected boolean hasOngoingTransaction() {
		if(!isSupervisedMode()) {
			return false;
		} else {
			if(ongoingTransactions != null) {
				for (Transaction transaction : ongoingTransactions) {
					if(TransactionState.CALLING.equals(transaction.getState()) ||
						TransactionState.TRYING.equals(transaction.getState()) ||
						TransactionState.PROCEEDING.equals(transaction.getState()) ||
						TransactionState.COMPLETED.equals(transaction.getState()) ||
						TransactionState.CONFIRMED.equals(transaction.getState())) {
							return true;
					}
				}
			}
			return false;
		}
	}
1021740
public boolean isFatalEnabled()
    {
        if (IS12)
        {
            return getLogger().isEnabledFor(Level.FATAL);
        }
        return getLogger().isEnabledFor(Level.FATAL);
    }
1333884
def exists?(header = self.class::DEFAULT_REQUEST_HEADER)
      retrieval_keys = self.class::UNIQUE_IDENTIFIERS.reject { |k| @data[k].nil? }
      raise IncompleteResource, "Must set resource #{self.class::UNIQUE_IDENTIFIERS.join(' or ')} before trying to retrieve!" if retrieval_keys.empty?
      retrieval_keys.each do |k|
        results = self.class.find_by(@client, { k => @data[k] }, self.class::BASE_URI, header)
        return true if results.size == 1
      end
      false
    end
624602
public static boolean isAvailable() {
        return isAvailable(ReactiveLibrary.PROJECT_REACTOR) || isAvailable(ReactiveLibrary.RXJAVA1)
                || isAvailable(ReactiveLibrary.RXJAVA2);
    }
36742
public boolean isAvailable() {
		// The channel is available is is connected
		boolean available = this.rtpChannel != null && this.rtpChannel.isConnected();
		// In case of WebRTC calls the DTLS handshake must be completed
		if(this.isWebRtc) {
			available = available && this.webRtcHandler.isHandshakeComplete();
		}
		return available;
	}
1141898
public boolean canRun() {
    Status status = getStatus();
    return Status.STATUS_READY.equals(status) || Status.STATUS_COMPLETE.equals(status);
  }