pentaho/pentaho-kettle · error · UnsupportedOperationException

Cannot assemble shared object of type

Error message

Cannot assemble shared object of type [%s]

What it means

During shared object loading, PurRepository looks up a SharedObjectAssembler for each repository object type found (e.g. DATABASE, TRANSFORMATION). If a file of a type with no registered assembler is present, an UnsupportedOperationException with this message is thrown.

Solutions

  1. Upgrade the PDI/pur plugin to a version that supports all object types present in the repository.
  2. Identify the offending type from the message and remove/move those files from the shared objects area.
  3. Register a custom SharedObjectAssembler for the type if you own the extension.
  4. Pin client and server to matching versions.

Example fix

// before
// older client hits unknown type and throws
// after
// upgrade client
<dependency>
  <groupId>org.pentaho.di</groupId>
  <artifactId>pdi-core</artifactId>
  <version>9.3.0.0-428</version> <!-- match server version -->
</dependency>
Defensive patterns

Strategy: try-catch

Validate before calling

// keep client and server versions aligned; check known types before load
Set<RepositoryObjectType> supported = sharedObjectAssemblerMap.keySet();
// ensure repository only contains types in `supported`

Type guard

boolean assemblable = t -> sharedObjectAssemblerMap.containsKey(t);

Try / catch

try { readSharedObjects(); } catch (UnsupportedOperationException e) { log.error("unknown shared type", e); }

Prevention

When it happens

Trigger: The repository contains files of a RepositoryObjectType that this PDI version does not know how to assemble (e.g. newer repository content read by an older client, or unsupported types like RDBMS-partitioned metadata in the shared folder).

Common situations: Version mismatch between PDI client and Pentaho Server/repository content; custom or new object types added server-side.

Understand the failure class

Background: UnsupportedOperationException and "is not supported" errors: when a library deliberately refuses a call — this error's family across 30 libraries.

Related errors

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

Appendix: source

Thrown at plugins/pur/core/src/main/java/org/pentaho/di/repository/pur/PurRepository.java:1411

    // Since type is not preserved in the RepositoryFile we fetch files by type so we don't rely on parsing the name to
    // determine type afterward
    // Map must be ordered or we can't match up files with data and version summary
    LinkedHashMap<RepositoryObjectType, List<RepositoryFile>> filesByType = getFilesByType( allFiles, types );
    readWriteLock.readLock().lock();
    try {
      List<NodeRepositoryFileData> data;
      List<VersionSummary> versions;
      data = pur.getDataForReadInBatch( allFiles, NodeRepositoryFileData.class );
      versions = pur.getVersionSummaryInBatch( allFiles );

      Iterator<NodeRepositoryFileData> dataIter = data.iterator();
      Iterator<VersionSummary> versionsIter = versions.iterator();

      // Assemble into completely loaded SharedObjectInterfaces by type
      for ( Entry<RepositoryObjectType, List<RepositoryFile>> entry : filesByType.entrySet() ) {
        SharedObjectAssembler<?> assembler = sharedObjectAssemblerMap.get( entry.getKey() );
        if ( assembler == null ) {
          throw new UnsupportedOperationException(
            String.format( "Cannot assemble shared object of type [%s]", entry.getKey() ) ); //$NON-NLS-1$
        }
        // For all files of this type, assemble them from the pieces of data pulled from the repository
        Iterator<RepositoryFile> filesIter = entry.getValue().iterator();
        List<SharedObjectInterface<?>> sharedObjects = new ArrayList<>( entry.getValue().size() );
        // Exceptions are thrown during lookup if data or versions aren't found so all the lists should be the same size
        // (no need to check for next on all iterators)
        while ( filesIter.hasNext() ) {
          RepositoryFile file = filesIter.next();
          NodeRepositoryFileData repoData = dataIter.next();
          VersionSummary version = versionsIter.next();

          // TODO: inexistent db types can cause exceptions assembling; prevent total failure
          try {
            sharedObjects.add( assembler.assemble( file, repoData, version ) );
          } catch ( Exception ex ) {
            // TODO i18n
            getLog().logError( "Unable to load shared objects", ex );

View on GitHub (pinned to f3058517a1)