RenditionMetadataWorkflowProcess.java

  1. /*
  2.  * #%L
  3.  * wcm.io
  4.  * %%
  5.  * Copyright (C) 2019 wcm.io
  6.  * %%
  7.  * Licensed under the Apache License, Version 2.0 (the "License");
  8.  * you may not use this file except in compliance with the License.
  9.  * You may obtain a copy of the License at
  10.  *
  11.  *      http://www.apache.org/licenses/LICENSE-2.0
  12.  *
  13.  * Unless required by applicable law or agreed to in writing, software
  14.  * distributed under the License is distributed on an "AS IS" BASIS,
  15.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16.  * See the License for the specific language governing permissions and
  17.  * limitations under the License.
  18.  * #L%
  19.  */
  20. package io.wcm.handler.mediasource.dam.impl.metadata;

  21. import static com.day.cq.dam.api.DamConstants.NT_DAM_ASSET;

  22. import java.util.List;
  23. import java.util.concurrent.locks.Lock;

  24. import org.apache.sling.api.resource.Resource;
  25. import org.apache.sling.api.resource.ResourceResolver;
  26. import org.jetbrains.annotations.NotNull;
  27. import org.osgi.service.component.annotations.Component;
  28. import org.osgi.service.component.annotations.Reference;
  29. import org.slf4j.Logger;
  30. import org.slf4j.LoggerFactory;

  31. import com.adobe.granite.workflow.WorkflowSession;
  32. import com.adobe.granite.workflow.collection.ResourceCollectionManager;
  33. import com.adobe.granite.workflow.exec.WorkItem;
  34. import com.adobe.granite.workflow.exec.WorkflowProcess;
  35. import com.adobe.granite.workflow.metadata.MetaDataMap;
  36. import com.day.cq.dam.api.Asset;
  37. import com.day.cq.dam.api.handler.store.AssetStore;
  38. import com.day.cq.dam.commons.util.DamUtil;

  39. import io.wcm.sling.commons.adapter.AdaptTo;

  40. /**
  41.  * Workflow process that generated rendition metadata required for the media handler processing.
  42.  * Can also process workflow packages.
  43.  */
  44. @Component(
  45.     service = WorkflowProcess.class,
  46.     property = {
  47.         "process.label=wcm.io Media Handler: Rendition Metadata"
  48.     })
  49. public final class RenditionMetadataWorkflowProcess implements WorkflowProcess {

  50.   private static final Logger log = LoggerFactory.getLogger(RenditionMetadataWorkflowProcess.class);

  51.   @Reference
  52.   private ResourceCollectionManager resourceCollectionManager;
  53.   @Reference
  54.   private AssetSynchonizationService assetSynchronizationService;
  55.   @Reference
  56.   private AssetStore assetStore;

  57.   @Override
  58.   public void execute(WorkItem item, WorkflowSession workflowSession, MetaDataMap args) {
  59.     String payloadPath = WorkflowProcessUtil.getPayloadResourcePath(item);
  60.     if (payloadPath == null) {
  61.       log.warn("Invalid payload: {}", item.getWorkflowData().getPayloadType());
  62.       return;
  63.     }

  64.     // collect asset(s) from payload
  65.     ResourceResolver resourceResolver = AdaptTo.notNull(workflowSession, ResourceResolver.class);
  66.     List<String> assetPaths = WorkflowProcessUtil.getPayloadResourcePaths(payloadPath,
  67.         NT_DAM_ASSET, resourceResolver, resourceCollectionManager);
  68.     if (assetPaths.isEmpty()) {
  69.       log.info("Did not found any asset reference in workflow payload: {}", payloadPath);
  70.     }
  71.     else {
  72.       log.info("Start processing {} asset references from workflow payload {} ...", assetPaths.size(), payloadPath);
  73.       log.debug("All asset references: {}", assetPaths);
  74.     }

  75.     // process all assets
  76.     for (String assetPath : assetPaths) {
  77.       process(assetPath, resourceResolver);
  78.     }

  79.     log.info("Finished processing {} asset references from workflow payload {}.", assetPaths.size(), payloadPath);
  80.   }

  81.   /**
  82.    * Process a single asset path.
  83.    * @param assetOrRenditionPath Path to asset or a rendition of it
  84.    * @param resourceResolver Resource resolver from workflow
  85.    */
  86.   private void process(@NotNull String assetOrRenditionPath, @NotNull ResourceResolver resourceResolver) {
  87.     // make sure asset exists
  88.     Asset asset = getAsset(assetOrRenditionPath, resourceResolver);
  89.     if (asset == null) {
  90.       log.debug("Unable to read asset at {} with user {}", assetOrRenditionPath, resourceResolver.getUserID());
  91.       return;
  92.     }

  93.     // process event synchronized per asset path
  94.     Lock lock = assetSynchronizationService.getLock(asset.getPath());
  95.     lock.lock();

  96.     try {
  97.       // refresh resource resolver to reflect changes on metadata probably made by listener service
  98.       resourceResolver.refresh();

  99.       // process asset renditions
  100.       RenditionMetadataGenerator generator = new RenditionMetadataGenerator(resourceResolver, assetStore);
  101.       generator.processAllRenditions(asset);
  102.     }
  103.     finally {
  104.       lock.unlock();
  105.     }
  106.   }

  107.   /**
  108.    * Get asset instance for given asset path.
  109.    * @param assetOrRenditionPath Path to asset or a rendition of it
  110.    * @return Asset or null if path is invalid
  111.    */
  112.   private Asset getAsset(String assetOrRenditionPath, ResourceResolver resolver) {
  113.     Resource resource = resolver.getResource(assetOrRenditionPath);
  114.     if (resource != null) {
  115.       return DamUtil.resolveToAsset(resource);
  116.     }
  117.     else {
  118.       return null;
  119.     }
  120.   }

  121. }