MediaPackageSupport.java
/*
* Licensed to The Apereo Foundation under one or more contributor license
* agreements. See the NOTICE file distributed with this work for additional
* information regarding copyright ownership.
*
*
* The Apereo Foundation licenses this file to you under the Educational
* Community License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of the License
* at:
*
* http://opensource.org/licenses/ecl2.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*
*/
package org.opencastproject.mediapackage;
import static org.apache.commons.lang3.StringUtils.isNotBlank;
import static org.opencastproject.util.IoSupport.withResource;
import static org.opencastproject.util.data.functions.Misc.chuck;
import org.apache.commons.io.FilenameUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.InputStream;
import java.net.URI;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
/** Utility class used for media package handling. */
public final class MediaPackageSupport {
/** Disable construction of this utility class */
private MediaPackageSupport() {
}
private static final List NIL = java.util.Collections.EMPTY_LIST;
/**
* Mode used when merging media packages.
* <p>
* <ul>
* <li><code>Merge</code> assigns a new identifier in case of conflicts</li>
* <li><code>Replace</code> replaces elements in the target media package with matching identifier</li>
* <li><code>Skip</code> skips elements from the source media package with matching identifer</li>
* <li><code>Fail</code> fail in case of conflicting identifier</li>
* </ul>
*/
public enum MergeMode {
Merge, Replace, Skip, Fail
}
/** the logging facility provided by log4j */
private static final Logger logger = LoggerFactory.getLogger(MediaPackageSupport.class.getName());
/**
* Merges the contents of media package located at <code>sourceDir</code> into the media package located at
* <code>targetDir</code>.
* <p>
* When choosing to move the media package element into the new place instead of copying them, the source media
* package folder will be removed afterwards.
* </p>
*
* @param dest
* the target media package directory
* @param src
* the source media package directory
* @param mode
* conflict resolution strategy in case of identical element identifier
* @throws MediaPackageException
* if an error occurs either accessing one of the two media packages or merging them
*/
public static MediaPackage merge(MediaPackage dest, MediaPackage src, MergeMode mode) throws MediaPackageException {
try {
for (MediaPackageElement e : src.elements()) {
if (dest.getElementById(e.getIdentifier()) == null)
dest.add(e);
else {
if (MergeMode.Replace == mode) {
logger.debug("Replacing element " + e.getIdentifier() + " while merging " + dest + " with " + src);
dest.remove(dest.getElementById(e.getIdentifier()));
dest.add(e);
} else if (MergeMode.Skip == mode) {
logger.debug("Skipping element " + e.getIdentifier() + " while merging " + dest + " with " + src);
continue;
} else if (MergeMode.Merge == mode) {
logger.debug("Renaming element " + e.getIdentifier() + " while merging " + dest + " with " + src);
e.setIdentifier(null);
dest.add(e);
} else if (MergeMode.Fail == mode) {
throw new MediaPackageException("Target media package " + dest + " already contains element with id "
+ e.getIdentifier());
}
}
}
} catch (UnsupportedElementException e) {
throw new MediaPackageException(e);
}
return dest;
}
/**
* Returns <code>true</code> if the media package contains an element with the specified identifier.
*
* @param identifier
* the identifier
* @return <code>true</code> if the media package contains an element with this identifier
*/
public static boolean contains(String identifier, MediaPackage mp) {
for (MediaPackageElement element : mp.getElements()) {
if (element.getIdentifier().equals(identifier))
return true;
}
return false;
}
/**
* Extract the file name from a media package elements URI.
*
* @return the file name or none if it could not be determined
*/
public static Optional<String> getFileName(MediaPackageElement mpe) {
URI uri = mpe.getURI();
if (uri == null) {
return Optional.empty();
}
String name = FilenameUtils.getName(uri.toString());
if (name == null || name.isBlank()) {
return Optional.empty();
}
return Optional.of(name);
}
/**
* Create a copy of the given media package.
* <p>
* ATTENTION: Copying changes the type of the media package elements, e.g. an element of
* type <code>DublinCoreCatalog</code> will become a <code>CatalogImpl</code>.
*/
public static MediaPackage copy(MediaPackage mp) {
return (MediaPackage) mp.clone();
}
/** Update a mediapackage element of a mediapackage. Mutates <code>mp</code>. */
public static void updateElement(MediaPackage mp, MediaPackageElement e) {
mp.removeElementById(e.getIdentifier());
mp.add(e);
}
/** {@link #updateElement(MediaPackage, MediaPackageElement)} as en effect. */
public static Consumer<MediaPackageElement> updateElement(final MediaPackage mp) {
return e -> updateElement(mp, e);
}
/** Filters and predicates to work with media package element collections. */
public static final class Filters {
private Filters() {
}
// functions implemented for monadic bind in order to cast types
public static final Predicate<MediaPackageElement> isPublication = Publication.class::isInstance;
public static final Predicate<MediaPackageElement> isNotPublication = isPublication.negate();
public static final Predicate<MediaPackageElement> hasChecksum = e -> e.getChecksum() != null;
public static final Predicate<MediaPackageElement> hasNoChecksum = hasChecksum.negate();
/** Filters publications to channel <code>channelId</code>. */
public static boolean ofChannel(Publication p, String channelId) {
return p.getChannel().equals(channelId);
}
/** Check if mediapackage element has any of the given tags. */
public static boolean hasTagAny(MediaPackageElement mpe, List<String> tags) {
return mpe.containsTag(tags);
}
/**
* Return true if the element has a flavor that matches <code>flavor</code>.
*
* @see MediaPackageElementFlavor#matches(MediaPackageElementFlavor)
*/
public static Function<MediaPackageElement, Boolean> matchesFlavor(final MediaPackageElementFlavor flavor) {
return mpe -> flavor.matches(mpe.getFlavor());
}
public static boolean isEpisodeDublinCore(MediaPackageElement mpe) {
// match is commutative
return MediaPackageElements.EPISODE.matches(mpe.getFlavor());
}
public static boolean isSmilCatalog(MediaPackageElement mpe) {
// match is commutative
return MediaPackageElements.SMIL.matches(mpe.getFlavor());
}
}
/**
* Basic sanity checking for media packages.
*
* <pre>
* // media package is ok
* sanityCheck(mp).isNone()
* </pre>
*
* @return none if the media package is a healthy condition, some([error_msgs]) otherwise
*/
public static Optional<List<String>> sanityCheck(MediaPackage mp) {
List<String> errors = java.util.stream.Stream.of(
mp.getIdentifier() == null ? "no ID" : null,
(mp.getIdentifier() != null && isNotBlank(mp.getIdentifier().toString())) ? null : "blank ID"
)
.filter(Objects::nonNull)
.collect(Collectors.toList());
return errors.isEmpty() ? Optional.empty() : Optional.of(errors);
}
/** To be used in unit tests. */
public static MediaPackage loadFromClassPath(String path) {
return withResource(
MediaPackageSupport.class.getResourceAsStream(path),
(InputStream is) -> {
try {
return MediaPackageBuilderFactory.newInstance()
.newMediaPackageBuilder()
.loadFromXml(is);
} catch (Exception e) {
return chuck(e);
}
}
);
}
}