private void strictMimetypeCheck(ContentReader reader, TransformationOptions options, String sourceMimetype)
    throws UnsupportedTransformationException
{
    if (strictMimeTypeCheck && depth.get() == 1)
    {
        String differentType = getMimetypeService().getMimetypeIfNotMatches(reader.getReader());

        if (!transformerConfig.strictMimetypeCheck(sourceMimetype, differentType))
        {
            String fileName = ((LegacyTransformerDebug)transformerDebug).getFileName(options, true, 0);
            String readerSourceMimetype = reader.getMimetype();
            String message = "Transformation of ("+fileName+
                ") has not taken place because the declared mimetype ("+
                readerSourceMimetype+") does not match the detected mimetype ("+
                differentType+").";
            logger.warn(message);
            throw new UnsupportedTransformationException(message);
        }
    }
}
 

@Override
public boolean isSupported(String sourceMimetype, long sourceSizeInBytes, String contentUrl, String targetMimetype,
                           Map<String, String> actualOptions, String transformName, NodeRef sourceNodeRef)
{
    String renditionName = TransformDefinition.convertToRenditionName(transformName);
    TransformationOptions transformationOptions = converter.getTransformationOptions(renditionName, actualOptions);
    transformationOptions.setSourceNodeRef(sourceNodeRef);

    ContentTransformer legacyTransform = getTransformer(contentUrl, sourceMimetype,
            sourceSizeInBytes, targetMimetype, transformationOptions);

    if (logger.isDebugEnabled())
    {
        logger.debug(TRANSFORM + renditionName + " from " + sourceMimetype +
                (legacyTransform == null ? " is unsupported" : " is supported"));
    }
    return legacyTransform != null;
}
 

private NodeRef createThumbnailNode(final NodeRef node, final QName contentProperty,
            final String mimetype, final TransformationOptions transformationOptions, final String thumbnailName,
            final ThumbnailParentAssociationDetails assocDetails)
{
    // Get the name of the thumbnail and add to properties map
    QName thumbnailQName = getThumbnailQName(thumbnailName);
    RenditionDefinition definition = createRenditionDefinition(contentProperty, mimetype,
                transformationOptions, thumbnailQName, assocDetails);
    try
    {
        ChildAssociationRef thumbnailAssoc = renditionService.render(node, definition);
        NodeRef thumbnail = getThumbnailNode(thumbnailAssoc);
        setThumbnailNameProperty(thumbnail, thumbnailName);
        return thumbnail;
    } catch (RenditionServiceException rsx)
    {
        throw new ThumbnailException(rsx.getMessage(), rsx);
    }
}
 

@Override
protected void transformRemote(RemoteTransformerClient remoteTransformerClient, ContentReader reader,
                               ContentWriter writer, TransformationOptions options, String sourceMimetype,
                               String targetMimetype, String sourceExtension, String targetExtension,
                               String targetEncoding) throws Exception
{
    String sourceEncoding = reader.getEncoding();
    long timeoutMs = options.getTimeoutMs();

    remoteTransformerClient.request(reader, writer, sourceMimetype, sourceExtension, targetExtension,
            timeoutMs, logger,
            "transformName", "string",
            "sourceMimetype", sourceMimetype,
            "targetMimetype", targetMimetype,
            "targetExtension", targetExtension,
            SOURCE_ENCODING, sourceEncoding,
            TARGET_ENCODING, targetEncoding);

}
 

@Override
protected void transformRemote(RemoteTransformerClient remoteTransformerClient, ContentReader reader,
                               ContentWriter writer, TransformationOptions options,
                               String sourceMimetype, String targetMimetype,
                               String sourceExtension, String targetExtension,
                               String targetEncoding) throws Exception
{
    long timeoutMs = options.getTimeoutMs();
    boolean recurse = includeContents;
    if(options.getIncludeEmbedded() != null)
    {
        recurse = options.getIncludeEmbedded();
    }
    remoteTransformerClient.request(reader, writer, sourceMimetype, sourceExtension, targetExtension,
            timeoutMs, logger,
            "transformName", "Archive",
            "includeContents", Boolean.toString(recurse),
            "sourceMimetype", sourceMimetype,
            "sourceExtension", sourceExtension,
            "targetMimetype", targetMimetype,
            TARGET_ENCODING, targetEncoding);
}
 

@Override
protected TransformationOptions getTransformOptionsImpl(TransformationOptions options, RenderingContext context)
{
    options.setSourceNodeRef(context.getSourceNode());

    ImageTransformationOptions imageTransformationOptions = (ImageTransformationOptions)options;
    
    String commandOptions = context.getCheckedParam(PARAM_COMMAND_OPTIONS, String.class);
    ImageResizeOptions imageResizeOptions = getImageResizeOptions(context);

    boolean autoOrient = context.getParamWithDefault(PARAM_AUTO_ORIENTATION, true);
    
    imageTransformationOptions.setResizeOptions(imageResizeOptions);
    imageTransformationOptions.setAutoOrient(autoOrient);
    if (commandOptions != null)
    {
        imageTransformationOptions.setCommandOptions(commandOptions);
    }
    
    return super.getTransformOptionsImpl(options, context);
}
 

/**
 * Returns the maximum source size (in KBytes) allowed given the supplied values.
 * @return 0 if the the transformation is disabled, -1 if there is no limit, otherwise the size in KBytes.
 */
@Override
public long getMaxSourceSizeKBytes(String sourceMimetype, String targetMimetype, TransformationOptions options)
{
    long maxSourceSizeKBytes = -1;
    
    // The maxSourceSizeKbytes value is ignored if this transformer is able to use
    // page limits and the limits include a pageLimit. Normally used in the creation
    // of icons. Note the readLimitKBytes value is not checked as the combined limits
    // only have the max or limit KBytes value set (the smaller value is returned).
    TransformationOptionLimits limits = getLimits(sourceMimetype, targetMimetype, options);
    if (!isPageLimitSupported(sourceMimetype, targetMimetype, options) || limits.getPageLimit() <= 0)
    {
        maxSourceSizeKBytes = limits.getMaxSourceSizeKBytes();
    }
    
    return maxSourceSizeKBytes;
}
 

@Deprecated
public ContentTransformer getTransformer(String sourceUrl, String sourceMimetype, long sourceSize, String targetMimetype, TransformationOptions options)
{
    List<ContentTransformer> transformers = null;
    try
    {
        transformerDebug.pushAvailable(sourceUrl, sourceMimetype, targetMimetype, options);
        List<ContentTransformer> activeTransformers = getActiveTransformers(sourceMimetype, sourceSize, targetMimetype, options);
        transformerDebug.availableTransformers(activeTransformers, sourceSize, options, "ContentService.getTransformer(...)");
        transformers = activeTransformers.isEmpty() ? null : activeTransformers;
    }
    finally
    {
        transformerDebug.popAvailable();
    }
    return (transformers == null) ? null : transformers.get(0);
}
 

/**
 * @see org.alfresco.repo.content.transform.ContentTransformer#isTransformable(java.lang.String, java.lang.String, org.alfresco.service.cmr.repository.TransformationOptions)
 */
@SuppressWarnings("deprecation")
public boolean isExplicitTransformation(String sourceMimetype, String targetMimetype, TransformationOptions options)
{
   boolean result = false;
   
   if (this.explicitTransformations != null)
   {
       for (ContentTransformerRegistry.TransformationKey transformationKey : this.explicitTransformations)
       {
           if (transformationKey.getSourceMimetype().equals(sourceMimetype) == true &&
               transformationKey.getTargetMimetype().equals(targetMimetype) == true)
           {
               result = true;
               break;
           }
       }
   }
   
   return result;
}
 

public void testGetTransformerEnabledDisabled() throws Exception
{
    TransformationOptions options = new TransformationOptions();

    Assert.assertNotNull(registry.getTransformer(MIMETYPE_TEXT_PLAIN, -1, MIMETYPE_TEXT_PLAIN, options));
    try
    {
        registry.setEnabled(false);
        Assert.assertNull(registry.getTransformer(MIMETYPE_TEXT_PLAIN, -1, MIMETYPE_TEXT_PLAIN, options));
    }
    finally
    {
        registry.setEnabled(true);
    }
    Assert.assertNotNull(registry.getTransformer(MIMETYPE_TEXT_PLAIN, -1, MIMETYPE_TEXT_PLAIN, options));
}
 

/**
 * See {@link TransformerConfig#isSupportedTransformation(ContentTransformer, String, String, TransformationOptions)}.
 */
public boolean isSupportedTransformation(ContentTransformer transformer, String sourceMimetype,
        String targetMimetype, TransformationOptions options)
{
    if (sourceMimetype == null)
    {
        sourceMimetype = ANY;
    }
    
    if (targetMimetype == null)
    {
        targetMimetype = ANY;
    }
    
    boolean isSupported = true;
    String name = transformer.getName();
    SupportedAndUnsupportedTransformations supportedBytransformer = supported.get(name);
    if (supportedBytransformer != null)
    {
        isSupported = supportedBytransformer.isSupported(sourceMimetype, targetMimetype);
    }
    return isSupported;
}
 

@Override
protected void transformRemote(RemoteTransformerClient remoteTransformerClient, ContentReader reader,
                               ContentWriter writer, TransformationOptions options,
                               String sourceMimetype, String targetMimetype,
                               String sourceExtension, String targetExtension,
                               String targetEncoding) throws Exception
{
    long timeoutMs = options.getTimeoutMs();

    remoteTransformerClient.request(reader, writer, sourceMimetype, sourceExtension, targetExtension,
            timeoutMs, logger,
            "transformName", transformerName,
            "sourceMimetype", sourceMimetype,
            "targetMimetype", targetMimetype,
            "targetExtension", targetExtension,
            TARGET_ENCODING, targetEncoding);
}
 

protected void transformInternal(ContentReader reader, ContentWriter writer, TransformationOptions options)
         throws Exception
 {
     TransformationOptionLimits original = options.getLimits();
     try
     {
         // Combine the transformer's limit values into the options so they are available to the worker
         options.setLimits(getLimits(reader, writer, options));

         // Perform the transformation
         this.worker.transform(reader, writer, options);
     }
     finally
     {
         options.setLimits(original);
     }
}
 

/**
 * Convenience method to check the transformability of a transformation
 * 
 * @param reader    content reader
 * @param writer    content writer
 * @param options   transformation options
 * @throws AlfrescoRuntimeException if the the transformation isn't supported
 */
protected void checkTransformable(ContentReader reader, ContentWriter writer, TransformationOptions options)
{
    String sourceMimetype = getMimetype(reader);
    String targetMimetype = getMimetype(writer);
    long sourceSize = reader.getSize();
    boolean transformable = isTransformable(sourceMimetype, sourceSize, targetMimetype, options);
    if (transformable == false)
    {
        // This method is only called once a transformer has been selected, so it should be able to
        // handle the mimetypes but might not be able to handle all the limits as it might be part of
        // of a complex (compound) transformer. So report the max size if set.
        long maxSourceSizeKBytes = getMaxSourceSizeKBytes(sourceMimetype, targetMimetype, options);
        boolean sizeOkay = maxSourceSizeKBytes < 0 || (maxSourceSizeKBytes > 0 && sourceSize <= maxSourceSizeKBytes*1024);
        AlfrescoRuntimeException e = new UnsupportedTransformationException("Unsupported transformation: " +
                getBeanName()+' '+sourceMimetype+" to "+targetMimetype+' '+
                (sizeOkay
                ? ""
                : transformerDebug.fileSize(sourceSize)+" > "+ transformerDebug.fileSize(maxSourceSizeKBytes*1024)));
        throw transformerDebug.setCause(e);
    }
    // it all checks out OK
}
 

@Deprecated
@Override
// Same as getTransformers, but without debug
public List<ContentTransformer> getActiveTransformers(String sourceMimetype,
                                                      String targetMimetype, TransformationOptions options)
{
    return getActiveTransformers(sourceMimetype, -1, targetMimetype, options);
}
 

/**
 * Constructor.  Specify the name of the thumbnail.
 * 
 * @param thumbnailName the name of the thumbnail, can be null
 */
public ThumbnailDefinition(String mimetype, TransformationOptions options, String thumbnailName)
{
    this(mimetype, options);
    this.name= thumbnailName;
    options.setUse(thumbnailName);
}
 

@Override
protected void transformRemote(RemoteTransformerClient remoteTransformerClient, ContentReader reader,
                               ContentWriter writer, TransformationOptions options, String sourceMimetype,
                               String targetMimetype, String sourceExtension, String targetExtension,
                               String targetEncoding) throws Exception
{
    long timeoutMs = options.getTimeoutMs();

    remoteTransformerClient.request(reader, writer, sourceMimetype, sourceExtension, targetExtension,
            timeoutMs, logger,
            "transformName", "appleIWorks",
            "sourceMimetype", sourceMimetype,
            "sourceExtension", sourceExtension,
            "targetMimetype", targetMimetype);
}
 

/**
 * @since 3.5
 */
public List<ContentTransformer> getActiveTransformers(String sourceMimetype, long sourceSize, String targetMimetype, TransformationOptions options)
{
    if (firstTime)
    {
        firstTime = false;
        transformerDebug.debug("Legacy transforms are " + (enabled ? "enabled" : "disabled"));
    }

    // Get the list of transformers
    List<ContentTransformer> transformers;
    if (enabled)
    {
        transformers = transformerSelector.selectTransformers(sourceMimetype, sourceSize, targetMimetype, options);

    }
    else
    {
        transformers = Collections.EMPTY_LIST;
    }
    if (logger.isDebugEnabled())
    {
        logger.debug("Searched for transformer: \n" +
                "   source mimetype: " + sourceMimetype + "\n" +
                "   target mimetype: " + targetMimetype + "\n" +
                "   transformers: " + transformers);
    }
    return transformers;
}
 

private void normalTest(boolean isAvailable)
{
    AbstractContentTransformer2 simple = new AbstractContentTransformer2() {
        @Override
        protected void transformInternal(ContentReader reader, ContentWriter writer,
                TransformationOptions options) throws Exception
        {
        }};
    simple.setBeanName("transformer.exampleSimple");
    
    when(transformerRegistry.getAllTransformers()).thenReturn(Arrays.asList(new ContentTransformer[] {(ContentTransformer)simple}));
    if (isAvailable)
    {
        when(transformerRegistry.getTransformers()).thenReturn(Arrays.asList(new ContentTransformer[] {(ContentTransformer)simple}));
    }
    when(transformerLog.getPropertyAndValue(any(Properties.class))).thenReturn("# transformer.log.entries=0");
    when(transformerDebugLog.getPropertyAndValue(any(Properties.class))).thenReturn("# transformer.debug.entries=0");

    String actual = new TransformerPropertyGetter(false, transformerProperties,
            mimetypeService, transformerRegistry, transformerLog, transformerDebugLog).toString();
    
    assertEquals("# LOG and DEBUG history sizes\n" +
            "# ===========================\n" +
            "# Use small values as these logs are held in memory. 0 to disable.\n" +
            "# transformer.log.entries=0\n" +
            "# transformer.debug.entries=0\n" +
            "\n" +
            "# Transformers without extra configuration settings\n" +
            "# =================================================\n" +
            "\n" +
            "# exampleSimple\n" +
            "# -------------\n" +
            (isAvailable ? "" : "# content.transformer.exampleSimple.available=false\n"), actual);
}
 

@Override
protected TransformationOptions newTransformationOptions(Action ruleAction, NodeRef sourceNodeRef)
{
    ImageTransformationOptions options = new ImageTransformationOptions();
    options.setSourceNodeRef(sourceNodeRef);
    options.setSourceContentProperty(ContentModel.PROP_NAME);
    options.setTargetContentProperty(ContentModel.PROP_NAME);
    
    String convertCommand = (String) ruleAction.getParameterValue(PARAM_CONVERT_COMMAND);
    options.setCommandOptions(convertCommand);

    return options;
}
 

@Override
public boolean isTransformableMimetype(String sourceMimetype,
        String targetMimetype, TransformationOptions options)
{
    // We'll arbitrarily claim to be able to transform PDF to PNG
    return MimetypeMap.MIMETYPE_PDF.equals(targetMimetype);
}
 

public TransformationCallable(ContentReader contentReader, String targetMimeType,
                              TransformationOptions transformationOptions, RenderingContext context, String initiatingUsername)
{
    this.contentReader = contentReader;
    this.targetMimeType = targetMimeType;
    String sourceMimetype = contentReader.getMimetype();
    this.options = converter.getOptions(transformationOptions, sourceMimetype, targetMimeType);
    this.context = context;
    this.initiatingUsername = initiatingUsername;
}
 

private boolean isPageLimitSupported(ContentTransformer transformer, String sourceMimetype,
        String targetMimetype, TransformationOptions options)
{
    return (transformer instanceof AbstractContentTransformerLimits)
        ? ((AbstractContentTransformerLimits)transformer).isPageLimitSupported(sourceMimetype, targetMimetype, options)
        : false;
}
 

/**
 * {@inheritDoc}<p>
 * 
 * Implementation calls the deprecated overloaded method without the sourceSize parameter
 * and then {@link #isTransformableSize(String, long, String, TransformationOptions)}.
 */
@Override
public boolean isTransformable(String sourceMimetype, long sourceSize, String targetMimetype, TransformationOptions options)
{
    // To make TransformerDebug output clearer, check the mimetypes and then the sizes.
    // If not done, 'unavailable' transformers due to size might be reported even
    // though they cannot transform the source to the target mimetype.

    return
        isSupportedTransformation(sourceMimetype, targetMimetype, options) &&
        isTransformableMimetype(sourceMimetype, targetMimetype, options) &&
        isTransformableSize(sourceMimetype, sourceSize, targetMimetype, options);
}
 

public void checkIsTransformable() throws Exception
{
    // check reliability
    boolean reliability = transformer.isTransformable(MimetypeMap.MIMETYPE_HTML, -1, MimetypeMap.MIMETYPE_TEXT_PLAIN, new TransformationOptions());
    assertTrue(reliability);   // plain text to plain text is supported
    
    // check other way around
    reliability = transformer.isTransformable(MimetypeMap.MIMETYPE_TEXT_PLAIN, -1, MimetypeMap.MIMETYPE_HTML, new TransformationOptions());
    assertFalse(reliability);   // plain text to plain text is not supported
}
 

@Override
public void transformInternal(ContentReader reader,
        ContentWriter writer, TransformationOptions options)
        throws Exception
{
    triggered.setValue(true);

    reader.getContentString();
    
    // alwaysFail
    throw new AlfrescoRuntimeException("Test code intentionally failed method call.");
}
 

/**
 * Returns max and limit values for time, size and pages for a specified source and
 * target mimetypes, combined with this Transformer's general limits and optionally
 * the supplied transformation option's limits.
 */
protected TransformationOptionLimits getLimits(ContentReader reader, ContentWriter writer,
        TransformationOptions options)
{
    return (reader == null || writer == null)
        ? transformerConfig.getLimits(this, null, null, options.getUse()).combine(options.getLimits())
        : getLimits(reader.getMimetype(), writer.getMimetype(), options);
}
 

/**
 * Pass on any limits to the reader. Will only do so if the reader is an
 * {@link AbstractContentReader}.
 * @param reader passed to {@link #transform(ContentReader, ContentWriter, TransformationOptions)}.
 * @param writer passed to {@link #transform(ContentReader, ContentWriter, TransformationOptions)}.
 * @param options passed to {@link #transform(ContentReader, ContentWriter, TransformationOptions)}.
 */
protected void setReaderLimits(ContentReader reader, ContentWriter writer,
        TransformationOptions options)
{
    if (reader instanceof AbstractContentReader)
    {
        AbstractContentReader abstractContentReader = (AbstractContentReader)reader;
        TransformationOptionLimits limits = getLimits(reader, writer, options);
        abstractContentReader.setLimits(limits);
        abstractContentReader.setTransformerDebug(transformerDebug);
    }
}
 

@Override
public boolean isTransformable(String sourceMimetype, long sourceSize, String targetMimetype, TransformationOptions options)
{
    if (!isAvailable())
    {
        return false;
    }

    return super.isTransformable(sourceMimetype, sourceSize, targetMimetype, options);
}
 

public void transformInternal(ContentReader reader, ContentWriter writer, TransformationOptions options)
        throws Exception
{
    if (remoteTransformerClientConfigured())
    {
        String sourceMimetype = getMimetype(reader);
        String targetMimetype = writer.getMimetype();
        String targetEncoding = writer.getEncoding();

        MimetypeService mimetypeService = getMimetypeService();
        String sourceExtension = mimetypeService.getExtension(sourceMimetype);
        String targetExtension = mimetypeService.getExtension(targetMimetype);
        if (sourceExtension == null || targetExtension == null)
        {
            throw new AlfrescoRuntimeException("Unknown extensions for mimetypes: \n" +
                    "   source mimetype: " + sourceMimetype + "\n" +
                    "   source extension: " + sourceExtension + "\n" +
                    "   target mimetype: " + targetMimetype + "\n" +
                    "   target extension: " + targetExtension + "\n" +
                    "   target encoding: " + targetEncoding);
        }

        transformRemote(remoteTransformerClient, reader, writer, options, sourceMimetype, targetMimetype,
                sourceExtension, targetExtension, targetEncoding);
    }
    else
    {
        transformLocal(reader, writer, options);
    }

    Log logger = getLogger();
    if (logger.isDebugEnabled())
    {
        logger.debug("Transformation completed: \n" +
                "   source: " + reader + "\n" +
                "   target: " + writer + "\n" +
                "   options: " + options);
    }
}