pentaho/pentaho-kettle · error · KettleException

There was an error passing the exported transformation to…

Error message

There was an error passing the exported transformation to the remote server:

What it means

Thrown by Trans.sendToSlaveServer(...) when exporting the transformation (with all referenced resources) as an archive to the remote server: SlaveServer.sendExport(...) to RegisterPackageServlet returned a WebResult that is not 'OK', so the remote server rejected or failed to import the exported transformation package.

Solutions

Read the appended webResult.getMessage() for the slave's import error and check the slave's carte.log.
Retry with a smaller/simpler export: confirm referenced connections/sub-transformations resolve before export.
Check the slave has disk space and write permission in its temp/upload directory.
Verify network stability during upload (timeouts on large archives).
Align Kettle versions between client and slave; alternatively send XML (register-trans servlet path) instead of an export.

Example fix

// before: unreadable referenced sub-transformation breaks export
// ensure references resolve before sending
transMeta.setFilename(null);
TopLevelResource res = ResourceUtil.serializeResourceExportInterface(...);
String result = slaveServer.sendExport(res.getArchiveName(), RegisterPackageServlet.TYPE_TRANS, res.getBaseResourceName());
// after: validate first
if (!new File(res.getArchiveName()).canRead()) throw new KettleException("Export archive missing");
String result = slaveServer.sendExport(res.getArchiveName(), RegisterPackageServlet.TYPE_TRANS, res.getBaseResourceName());

Defensive patterns

Strategy: try-catch

Validate before calling

// verify the export archive exists and referenced resources resolve before sending
File archive = new File(topLevelResource.getArchiveName());
if (!archive.canRead() || archive.length() == 0) {
  throw new KettleException("Export archive missing or empty: " + archive);
}

Try / catch

try {
  Trans.sendToSlaveServer(transMeta, config, repository, metaStore);
} catch (KettleException e) {
  if (e.getMessage() != null && e.getMessage().contains("exported transformation")) {
    log.error("Slave rejected export: " + e.getMessage(), e);
    // check slave disk space/permissions and version, then retry
  } else throw e;
}

Prevention

Confirm all referenced connections/sub-transformations resolve before export.
Check slave disk space and temp write permissions.
Keep client and slave Kettle versions aligned.
For large archives, raise upload timeouts and avoid intermediaries.

When it happens

Trigger: Remote execution with exporting (send to slave as exported zip) enabled: slave's register-package servlet answers with an error after receiving the archive, e.g. failed to unzip, invalid archive contents, or the referenced resources could not be materialized remotely.

Common situations: Transformation references repository objects not exported correctly; archive too large or truncated on upload; slave's file system lacks write space/permissions for the export; Kettle version mismatch causing import failure.

Related errors

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

Appendix: source

Thrown at engine/src/main/java/org/pentaho/di/trans/Trans.java:4380

          //the executionConfiguration should not include a repository here because all the resources should be
          //retrieved from the exported zip file
          TransExecutionConfiguration clonedConfiguration = (TransExecutionConfiguration) executionConfiguration.clone();
          clonedConfiguration.setRepository( null );
          Bowl globalBowl = repository != null ? repository.getBowl() : DefaultBowl.getInstance();
          TopLevelResource topLevelResource =
            ResourceUtil.serializeResourceExportInterface( transMeta.getBowl(), globalBowl, tempFile.getName().toString(),
              transMeta, transMeta, repository, metaStore, clonedConfiguration.getXML(),
              CONFIGURATION_IN_EXPORT_FILENAME );

          // Send the zip file over to the slave server...
          //
          String result = slaveServer.sendExport(
            topLevelResource.getArchiveName(),
            RegisterPackageServlet.TYPE_TRANS,
            topLevelResource.getBaseResourceName() );
          WebResult webResult = WebResult.fromXMLString( result );
          if ( !webResult.getResult().equalsIgnoreCase( WebResult.STRING_OK ) ) {
            throw new KettleException( "There was an error passing the exported transformation to the remote server: "
              + Const.CR + webResult.getMessage() );
          }
          carteObjectId = webResult.getId();
        }
      } else {

        // Now send it off to the remote server...
        //
        String xml = new TransConfiguration( transMeta, executionConfiguration ).getXML();
        String reply = slaveServer.sendXML( xml, RegisterTransServlet.CONTEXT_PATH + "/?xml=Y" );
        WebResult webResult = WebResult.fromXMLString( reply );
        if ( !webResult.getResult().equalsIgnoreCase( WebResult.STRING_OK ) ) {
          throw new KettleException( "There was an error posting the transformation on the remote server: " + Const.CR
            + webResult.getMessage() );
        }
        carteObjectId = webResult.getId();
      }

View on GitHub (pinned to f3058517a1)