private boolean _suspend(long time, TimeUnit unit, boolean failOnError) throws IllegalStateException { boolean suspendSuccessful = false; try { executionStateMonitor.enter(); switch (executionState) { case RESUMED: break; case SUSPENDED: case CANCELLED: if (failOnError) { throw new IllegalStateException( LocalizationMessages.ILLEGAL_INVOCATION_CONTEXT_STATE(executionState, "suspend")); } break; case RUNNING: executionState = State.SUSPENDED; suspendSuccessful = true; } } finally { executionStateMonitor.leave(); } // we don't want to invoke the callback or log message // as part of the synchronized code if (suspendSuccessful) { callback.suspended(time, unit, this); } else { // already resumed - just log fine message & ignore the call LOGGER.log(Level.FINE, LocalizationMessages.REQUEST_SUSPEND_FAILED(executionState)); } return suspendSuccessful; }
/** * Convert {@code Object} value to a value of the specified class type. * * @param value {@code Object} value to convert. * @param type conversion type. * @param <T> converted value type. * @return value converted to the specified class type. */ public static <T> T convertValue(Object value, Class<T> type) { if (!type.isInstance(value)) { // TODO: Move string value readers from server to common and utilize them here final Constructor constructor = AccessController.doPrivileged(ReflectionHelper.getStringConstructorPA(type)); if (constructor != null) { try { return type.cast(constructor.newInstance(value)); } catch (Exception e) { // calling the constructor wasn't successful - ignore and try valueOf() } } final Method valueOf = AccessController.doPrivileged(ReflectionHelper.getValueOfStringMethodPA(type)); if (valueOf != null) { try { return type.cast(valueOf.invoke(null, value)); } catch (Exception e) { // calling valueOf wasn't successful } } // at this point we don't know what to return -> return null if (LOGGER.isLoggable(Level.WARNING)) { LOGGER.warning( LocalizationMessages.PROPERTIES_HELPER_GET_VALUE_NO_TRANSFORM( String.valueOf(value), value.getClass().getName(), type.getName())); } return null; } return type.cast(value); }
/** * Invoke request on the wrapped inflector. The adapter itself serves as a {@link ListenableFuture * listenable response future}. * * @param request request data to be processed. */ public ListenableFuture<RESPONSE> apply(REQUEST request) { originatingRequest.set(request); final RESPONSE response; try { response = wrapped.apply(request); if (executionStateMonitor.enterIf(runningState)) { // The context was not suspended during the call to the wrapped inflector's apply(...) // method; // mark as resumed & don't invoke callback.resume() since we are resuming synchronously try { executionState = State.RESUMED; set(response); } finally { executionStateMonitor.leave(); } } else if (response != null) { LOGGER.log(Level.FINE, LocalizationMessages.REQUEST_SUSPENDED_RESPONSE_IGNORED(response)); } } catch (Throwable t) { resume(t); // resume with throwable (if not resumed by an external event already) } return this; }
@Override public Object convert(String s) { if (s.length() != 1) { throw new MessageBodyProcessingException( LocalizationMessages.ERROR_ENTITY_PROVIDER_BASICTYPES_CHARACTER_MORECHARS()); } return s.charAt(0); }
/** * Extract and return service locator from {@link javax.ws.rs.core.FeatureContext featureContext}. * The method can be used to inject custom types into a {@link javax.ws.rs.core.Feature}. * * <p>Note that features are utilized during initialization phase when not all providers are * registered yet. It is undefined which injections are already available in this phase. * * @param featureContext Feature context. * @return Service locator. * @throws java.lang.IllegalArgumentException when {@code writerInterceptorContext} is not a * default Jersey instance provided by Jersey in {@link * javax.ws.rs.core.Feature#configure(javax.ws.rs.core.FeatureContext)} method. */ public static ServiceLocator getServiceLocator(FeatureContext featureContext) { if (!(featureContext instanceof ServiceLocatorSupplier)) { throw new IllegalArgumentException( LocalizationMessages.ERROR_SERVICE_LOCATOR_PROVIDER_INSTANCE_FEATURE_CONTEXT( featureContext.getClass().getName())); } return ((ServiceLocatorSupplier) featureContext).getServiceLocator(); }
/** * Extract and return service locator from {@link javax.ws.rs.ext.ReaderInterceptorContext * readerInterceptorContext}. The method can be used to inject custom types into a {@link * javax.ws.rs.ext.ReaderInterceptor}. * * @param readerInterceptorContext Reader interceptor context. * @return Service locator. * @throws java.lang.IllegalArgumentException when {@code readerInterceptorContext} is not a * default Jersey implementation provided by Jersey as argument in the {@link * javax.ws.rs.ext.ReaderInterceptor#aroundReadFrom(javax.ws.rs.ext.ReaderInterceptorContext)} * method. */ public static ServiceLocator getServiceLocator( ReaderInterceptorContext readerInterceptorContext) { if (!(readerInterceptorContext instanceof ServiceLocatorSupplier)) { throw new IllegalArgumentException( LocalizationMessages .ERROR_SERVICE_LOCATOR_PROVIDER_INSTANCE_FEATURE_READER_INTERCEPTOR_CONTEXT( readerInterceptorContext.getClass().getName())); } return ((ServiceLocatorSupplier) readerInterceptorContext).getServiceLocator(); }
/** * Convert {@link Link} instance to a string version. * * @param value link instance to be stringified. * @return string version of a given link instance. */ static String stringfy(Link value) { throwIllegalArgumentExceptionIfNull(value, LocalizationMessages.LINK_IS_NULL()); Map<String, String> map = value.getParams(); StringBuilder sb = new StringBuilder(); sb.append('<').append(value.getUri()).append('>'); for (Map.Entry<String, String> entry : map.entrySet()) { sb.append("; ").append(entry.getKey()).append("=\"").append(entry.getValue()).append("\""); } return sb.toString(); }
@Override public Object readFrom( Class<Object> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException { final String entityString = readFromAsString(entityStream, mediaType); if (entityString.isEmpty()) { throw new NoContentException(LocalizationMessages.ERROR_READING_ENTITY_MISSING()); } final PrimitiveTypes primitiveType = PrimitiveTypes.forType(type); if (primitiveType != null) { return primitiveType.convert(entityString); } final Constructor constructor = AccessController.doPrivileged(ReflectionHelper.getStringConstructorPA(type)); if (constructor != null) { try { return type.cast(constructor.newInstance(entityString)); } catch (Exception e) { throw new MessageBodyProcessingException( LocalizationMessages.ERROR_ENTITY_PROVIDER_BASICTYPES_CONSTRUCTOR(type)); } } if (AtomicInteger.class.isAssignableFrom(type)) { return new AtomicInteger((Integer) PrimitiveTypes.INTEGER.convert(entityString)); } if (AtomicLong.class.isAssignableFrom(type)) { return new AtomicLong((Long) PrimitiveTypes.LONG.convert(entityString)); } throw new MessageBodyProcessingException( LocalizationMessages.ERROR_ENTITY_PROVIDER_BASICTYPES_UNKWNOWN(type)); }
private static Object getLegacyFallbackValue( Map<String, ?> properties, Map<String, String> legacyFallbackMap, String key) { if (legacyFallbackMap == null || !legacyFallbackMap.containsKey(key)) { return null; } String fallbackKey = legacyFallbackMap.get(key); Object value = properties.get(fallbackKey); if (value != null && LOGGER.isLoggable(Level.CONFIG)) { LOGGER.config( LocalizationMessages.PROPERTIES_HELPER_DEPRECATED_PROPERTY_NAME(fallbackKey, key)); } return value; }
@Override public void cancel() { if (executionStateMonitor.enterIf(cancellableState)) { try { executionState = State.CANCELLED; } finally { executionStateMonitor.leave(); } super.cancel(true); } else { // just log fine message & ignore the call LOGGER.log(Level.FINE, LocalizationMessages.REQUEST_CANCEL_FAILED(executionState)); } }
private void resume(final Runnable resumeHandler) { if (executionStateMonitor.enterIf(resumableState)) { final boolean invokeCallback; try { invokeCallback = executionState == State.SUSPENDED; executionState = State.RESUMED; } finally { executionStateMonitor.leave(); } try { resumeHandler.run(); } finally { if (invokeCallback) { callback.resumed(); } } } else { throw new IllegalStateException( LocalizationMessages.ILLEGAL_INVOCATION_CONTEXT_STATE(executionState, "resume")); } }
/** * Initialize an existing Jersey link builder with the link data provided in a form of a string. * * @param lb link builder to be initialized. * @param value link data as a string. * @return initialized link builder. */ static JerseyLink.Builder initBuilder(JerseyLink.Builder lb, String value) { throwIllegalArgumentExceptionIfNull(value, LocalizationMessages.LINK_IS_NULL()); try { value = value.trim(); String params; if (value.startsWith("<")) { int gtIndex = value.indexOf('>'); if (gtIndex != -1) { lb.uri(value.substring(1, gtIndex).trim()); params = value.substring(gtIndex + 1).trim(); } else { throw new IllegalArgumentException("Missing token > in " + value); } } else { throw new IllegalArgumentException("Missing starting token < in " + value); } if (params != null) { StringTokenizer st = new StringTokenizer(params, ";=\"", true); while (st.hasMoreTokens()) { checkToken(st, ";"); String n = st.nextToken().trim(); checkToken(st, "="); checkToken(st, "\""); String v = st.nextToken(); checkToken(st, "\""); lb.param(n, v); } } } catch (Throwable e) { if (LOGGER.isLoggable(Level.FINER)) { LOGGER.log(Level.FINER, "Error parsing link value '" + value + "'", e); } lb = null; } if (lb == null) { throw new IllegalArgumentException("Unable to parse link " + value); } return lb; }
@Override public final Object readFrom( Class<Object> type, Type genericType, Annotation annotations[], MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream inputStream) throws IOException { try { final EntityInputStream entityStream = EntityInputStream.create(inputStream); if (entityStream.isEmpty()) { throw new NoContentException(LocalizationMessages.ERROR_READING_ENTITY_MISSING()); } return readFrom(type, mediaType, getUnmarshaller(type, mediaType), entityStream); } catch (UnmarshalException ex) { throw new BadRequestException(ex); } catch (JAXBException ex) { throw new InternalServerErrorException(ex); } }
/** * Create new SSL context instance using the current SSL context configuration. * * @return newly configured SSL context instance. */ public SSLContext createSSLContext() { TrustManagerFactory trustManagerFactory = null; KeyManagerFactory keyManagerFactory = null; KeyStore _keyStore = keyStore; if (_keyStore == null && (keyStoreBytes != null || keyStoreFile != null)) { try { if (keyStoreProvider != null) { _keyStore = KeyStore.getInstance( keyStoreType != null ? keyStoreType : KeyStore.getDefaultType(), keyStoreProvider); } else { _keyStore = KeyStore.getInstance(keyStoreType != null ? keyStoreType : KeyStore.getDefaultType()); } InputStream keyStoreInputStream = null; try { if (keyStoreBytes != null) { keyStoreInputStream = new ByteArrayInputStream(keyStoreBytes); } else if (!keyStoreFile.equals("NONE")) { keyStoreInputStream = new FileInputStream(keyStoreFile); } _keyStore.load(keyStoreInputStream, keyStorePass); } finally { try { if (keyStoreInputStream != null) { keyStoreInputStream.close(); } } catch (IOException ignored) { } } } catch (KeyStoreException e) { throw new IllegalStateException(LocalizationMessages.SSL_KS_IMPL_NOT_FOUND(), e); } catch (CertificateException e) { throw new IllegalStateException(LocalizationMessages.SSL_KS_CERT_LOAD_ERROR(), e); } catch (FileNotFoundException e) { throw new IllegalStateException( LocalizationMessages.SSL_KS_FILE_NOT_FOUND(keyStoreFile), e); } catch (IOException e) { throw new IllegalStateException(LocalizationMessages.SSL_KS_LOAD_ERROR(keyStoreFile), e); } catch (NoSuchProviderException e) { throw new IllegalStateException(LocalizationMessages.SSL_KS_PROVIDERS_NOT_REGISTERED(), e); } catch (NoSuchAlgorithmException e) { throw new IllegalStateException( LocalizationMessages.SSL_KS_INTEGRITY_ALGORITHM_NOT_FOUND(), e); } } if (_keyStore != null) { String kmfAlgorithm = keyManagerFactoryAlgorithm; if (kmfAlgorithm == null) { kmfAlgorithm = AccessController.doPrivileged( PropertiesHelper.getSystemProperty( KEY_MANAGER_FACTORY_ALGORITHM, KeyManagerFactory.getDefaultAlgorithm())); } try { if (keyManagerFactoryProvider != null) { keyManagerFactory = KeyManagerFactory.getInstance(kmfAlgorithm, keyManagerFactoryProvider); } else { keyManagerFactory = KeyManagerFactory.getInstance(kmfAlgorithm); } final char[] password = keyPass != null ? keyPass : keyStorePass; if (password != null) { keyManagerFactory.init(_keyStore, password); } else { String ksName = keyStoreProvider != null ? LocalizationMessages.SSL_KMF_NO_PASSWORD_FOR_PROVIDER_BASED_KS() : keyStoreBytes != null ? LocalizationMessages.SSL_KMF_NO_PASSWORD_FOR_BYTE_BASED_KS() : keyStoreFile; LOGGER.config(LocalizationMessages.SSL_KMF_NO_PASSWORD_SET(ksName)); keyManagerFactory = null; } } catch (KeyStoreException e) { throw new IllegalStateException(LocalizationMessages.SSL_KMF_INIT_FAILED(), e); } catch (UnrecoverableKeyException e) { throw new IllegalStateException(LocalizationMessages.SSL_KMF_UNRECOVERABLE_KEY(), e); } catch (NoSuchAlgorithmException e) { throw new IllegalStateException(LocalizationMessages.SSL_KMF_ALGORITHM_NOT_SUPPORTED(), e); } catch (NoSuchProviderException e) { throw new IllegalStateException(LocalizationMessages.SSL_KMF_PROVIDER_NOT_REGISTERED(), e); } } KeyStore _trustStore = trustStore; if (_trustStore == null && (trustStoreBytes != null || trustStoreFile != null)) { try { if (trustStoreProvider != null) { _trustStore = KeyStore.getInstance( trustStoreType != null ? trustStoreType : KeyStore.getDefaultType(), trustStoreProvider); } else { _trustStore = KeyStore.getInstance( trustStoreType != null ? trustStoreType : KeyStore.getDefaultType()); } InputStream trustStoreInputStream = null; try { if (trustStoreBytes != null) { trustStoreInputStream = new ByteArrayInputStream(trustStoreBytes); } else if (!trustStoreFile.equals("NONE")) { trustStoreInputStream = new FileInputStream(trustStoreFile); } _trustStore.load(trustStoreInputStream, trustStorePass); } finally { try { if (trustStoreInputStream != null) { trustStoreInputStream.close(); } } catch (IOException ignored) { } } } catch (KeyStoreException e) { throw new IllegalStateException(LocalizationMessages.SSL_TS_IMPL_NOT_FOUND(), e); } catch (CertificateException e) { throw new IllegalStateException(LocalizationMessages.SSL_TS_CERT_LOAD_ERROR(), e); } catch (FileNotFoundException e) { throw new IllegalStateException( LocalizationMessages.SSL_TS_FILE_NOT_FOUND(trustStoreFile), e); } catch (IOException e) { throw new IllegalStateException(LocalizationMessages.SSL_TS_LOAD_ERROR(trustStoreFile), e); } catch (NoSuchProviderException e) { throw new IllegalStateException(LocalizationMessages.SSL_TS_PROVIDERS_NOT_REGISTERED(), e); } catch (NoSuchAlgorithmException e) { throw new IllegalStateException( LocalizationMessages.SSL_TS_INTEGRITY_ALGORITHM_NOT_FOUND(), e); } } if (_trustStore != null) { String tmfAlgorithm = trustManagerFactoryAlgorithm; if (tmfAlgorithm == null) { tmfAlgorithm = AccessController.doPrivileged( PropertiesHelper.getSystemProperty( TRUST_MANAGER_FACTORY_ALGORITHM, TrustManagerFactory.getDefaultAlgorithm())); } try { if (trustManagerFactoryProvider != null) { trustManagerFactory = TrustManagerFactory.getInstance(tmfAlgorithm, trustManagerFactoryProvider); } else { trustManagerFactory = TrustManagerFactory.getInstance(tmfAlgorithm); } trustManagerFactory.init(_trustStore); } catch (KeyStoreException e) { throw new IllegalStateException(LocalizationMessages.SSL_TMF_INIT_FAILED(), e); } catch (NoSuchAlgorithmException e) { throw new IllegalStateException(LocalizationMessages.SSL_TMF_ALGORITHM_NOT_SUPPORTED(), e); } catch (NoSuchProviderException e) { throw new IllegalStateException(LocalizationMessages.SSL_TMF_PROVIDER_NOT_REGISTERED(), e); } } try { String secProtocol = "TLS"; if (securityProtocol != null) { secProtocol = securityProtocol; } final SSLContext sslContext = SSLContext.getInstance(secProtocol); sslContext.init( keyManagerFactory != null ? keyManagerFactory.getKeyManagers() : null, trustManagerFactory != null ? trustManagerFactory.getTrustManagers() : null, null); return sslContext; } catch (KeyManagementException e) { throw new IllegalStateException(LocalizationMessages.SSL_CTX_INIT_FAILED(), e); } catch (NoSuchAlgorithmException e) { throw new IllegalStateException(LocalizationMessages.SSL_CTX_ALGORITHM_NOT_SUPPORTED(), e); } }