pentaho/pentaho-kettle · error · KettleException

Request could not be processed

Error message

Request could not be processed

What it means

Rest.getResponse catches any Exception thrown while executing the JAX-RS request (after method dispatch) and rethrows it as a KettleException with the literal message 'Request could not be processed', preserving the cause. It means request execution itself failed — not an HTTP error status from the server, but a client-side processing failure.

Solutions

1. Inspect the cause exception for the real problem (SocketTimeoutException, SSLHandshakeException, ProcessingException, etc.)
2. Increase the connection/read timeout if the cause is a timeout
3. Fix the trust store or enable the 'ignore SSL' option for certificate issues
4. Verify the body/content-type combination is valid for the chosen method
5. Check network connectivity and proxy configuration on the host running the transformation

Example fix

// before
response = invocationBuilder.post( getEntity( contentType, entityString ) );
// after
Entity<?> entity = getEntity( contentType, entityString );
if ( entity == null && ( entityString != null && !entityString.isEmpty() ) ) {
  throw new KettleException( "Cannot build entity for content type " + contentType );
}
response = invocationBuilder.post( entity );

// sanity-check inputs before invoking the request
if ( entityString != null && contentType == null ) {
  throw new KettleException( "Body provided without a content type" );
}
if ( data.realUrl == null || data.realUrl.isEmpty() ) {
  throw new KettleException( "Request URL is empty" );
}

try {
  Response r = step.getResponse( target, row, contentType, entity );
} catch ( KettleException e ) {
  if ( "Request could not be processed".equals( e.getMessage() ) ) {
    Throwable cause = e.getCause();
    if ( cause instanceof java.net.SocketTimeoutException ) { /* retry with longer timeout */ }
    else if ( cause instanceof javax.net.ssl.SSLHandshakeException ) { /* fix trust store / ignore SSL */ }
    log.error( "REST request execution failed", e );
  }
}

When it happens

Trigger: Exceptions from invocationBuilder.put/post/delete/head/options/method calls: connection I/O errors, SSL handshake failures, timeouts, invalid entity/body for the content type, or client-state problems.

Common situations: Connection reset or timeout to a slow endpoint; SSL certificate not trusted (handshake failure during execution); sending an entity with GET/DELETE where the client rejects it; RESTEasy/Jersey runtime errors.

Understand the failure class

Background: 'Something went wrong' / 'Request failed (500)' / 'HTTP error! status: 404' — what failed HTTP requests actually mean and how to find the real cause — this error's family across 28 libraries.

Related errors

• HTTP.Error.UnknownHostException
• HTTP.Exception.IllegalStatusCode
• HTTP.Log.UnableGetResult
• HTTPPOST.Exception.IllegalStatusCode
• Rest.Error.CanNotReadURL

AI-assisted analysis of pentaho/pentaho-kettle@f3058517a1 (2026-09-13). Data as JSON: /api/errors/b308a5d81a3ac465. Report an issue: GitHub.

Appendix: source

Thrown at plugins/rest/core/src/main/java/org/pentaho/di/trans/steps/rest/Rest.java:285

   * @throws KettleException in case the request could not be processed
   */
  private Response getResponse( Invocation.Builder invocationBuilder, String contentType, String entityString )
    throws KettleException {
    Response response;
    try {
      switch ( data.method ) {
        case RestMeta.HTTP_METHOD_GET -> response = invocationBuilder.get( Response.class );
        case RestMeta.HTTP_METHOD_POST -> response = invocationBuilder.post( getEntity( contentType, entityString ) );
        case RestMeta.HTTP_METHOD_PUT -> response = invocationBuilder.put( getEntity( contentType, entityString ) );
        case RestMeta.HTTP_METHOD_DELETE -> response = invocationBuilder.delete();
        case RestMeta.HTTP_METHOD_HEAD -> response = invocationBuilder.head();
        case RestMeta.HTTP_METHOD_OPTIONS -> response = invocationBuilder.options();
        case RestMeta.HTTP_METHOD_PATCH ->
          response = invocationBuilder.method( RestMeta.HTTP_METHOD_PATCH, getEntity( contentType, entityString ) );
        default -> throw new KettleException( BaseMessages.getString( PKG, "Rest.Error.UnknownMethod", data.method ) );
      }
    } catch ( Exception e ) {
      throw new KettleException( "Request could not be processed", e );
    }
    return response;
  }

  /**
   * Get entity for request using the given content type or the default one
   *
   * @param contentType  the content type
   * @param entityString the entity string
   * @return the request entity built using the given content type or the default media type
   */
  private Entity<?> getEntity( String contentType, String entityString ) {
    Entity<?> entity;

    if ( null != contentType ) {
      entity = Entity.entity( entityString, contentType );
    } else {
      entity = Entity.entity( entityString, data.mediaType );

View on GitHub (pinned to f3058517a1)