Example usage for org.apache.commons.lang BooleanUtils toBoolean

Introduction

In this page you can find the example usage for org.apache.commons.lang BooleanUtils toBoolean.

Prototype

public static boolean toBoolean(String str) 

Source Link

Document

Converts a String to a boolean (optimised for performance).

'true', 'on' or 'yes' (case insensitive) will return true.

Usage

From source file:org.opencastproject.dataloader.EventsLoader.java

/**
 * Callback on component activation./*from   www. j a v a  2  s.c  o m*/
 */
protected void activate(ComponentContext cc) throws Exception {
    boolean loadTestData = BooleanUtils
            .toBoolean(cc.getBundleContext().getProperty("org.opencastproject.dataloader.testdata"));

    String csvPath = StringUtils
            .trimToNull(cc.getBundleContext().getProperty("org.opencastproject.dataloader.csv"));

    systemUserName = cc.getBundleContext().getProperty(SecurityUtil.PROPERTY_KEY_SYS_USER);

    File csv = new File(csvPath);

    // Load the demo users, if necessary
    if (loadTestData && csv.exists() && serviceRegistry.count(null, null) == 0) {
        // Load events by CSV file
        new Loader(csv).start();
    }
}

---

From source file:org.opencastproject.dataloader.EventsLoader.java

private List<EventEntry> parseCSV(CSVParser csv) {
    List<EventEntry> arrayList = new ArrayList<EventEntry>();
    for (CSVRecord record : csv) {
        String title = record.get(0);
        String description = StringUtils.trimToNull(record.get(1));
        String series = StringUtils.trimToNull(record.get(2));
        String seriesName = StringUtils.trimToNull(record.get(3));

        Integer days = Integer.parseInt(record.get(4));
        float signum = Math.signum(days);
        DateTime now = DateTime.now();/*from   ww  w  .j a  va  2s .  c o  m*/
        if (signum > 0) {
            now = now.plusDays(days);
        } else if (signum < 0) {
            now = now.minusDays(days * -1);
        }

        Integer duration = Integer.parseInt(record.get(5));
        boolean archive = BooleanUtils.toBoolean(record.get(6));
        String agent = StringUtils.trimToNull(record.get(7));
        String source = StringUtils.trimToNull(record.get(8));
        String contributor = StringUtils.trimToNull(record.get(9));
        List<String> presenters = Arrays
                .asList(StringUtils.split(StringUtils.trimToEmpty(record.get(10)), ","));
        EventEntry eventEntry = new EventEntry(title, now.toDate(), duration, archive, series, agent, source,
                contributor, description, seriesName, presenters);
        arrayList.add(eventEntry);
    }
    return arrayList;
}

---

From source file:org.opencastproject.kernel.scanner.AbstractBufferScanner.java

@SuppressWarnings("rawtypes")
public void updated(Dictionary properties) throws ConfigurationException {
    String cronExpression;//from  ww  w  .  j a v a  2s. co m
    boolean enabled;

    unschedule();

    if (properties != null) {
        logger.debug("Updating configuration...");

        enabled = BooleanUtils.toBoolean((String) properties.get(PARAM_KEY_ENABLED));
        setEnabled(enabled);
        logger.debug("enabled = " + enabled);

        cronExpression = (String) properties.get(PARAM_KEY_CRON_EXPR);
        if (StringUtils.isBlank(cronExpression) || !CronExpression.isValidExpression(cronExpression))
            throw new ConfigurationException(PARAM_KEY_CRON_EXPR, "Cron expression must be valid");
        setCronExpression(cronExpression);
        logger.debug("cronExpression = '" + cronExpression + "'");

        try {
            buffer = Long.valueOf((String) properties.get(PARAM_KEY_BUFFER));
            if (buffer < 0) {
                throw new ConfigurationException(PARAM_KEY_BUFFER, "Buffer must be 0 or greater");
            }
        } catch (NumberFormatException e) {
            throw new ConfigurationException(PARAM_KEY_BUFFER, "Buffer must be a valid integer", e);
        }
        logger.debug("buffer = " + buffer);
    }

    schedule();
}

---

From source file:org.opencastproject.staticfiles.endpoint.StaticFileRestService.java

/**
 * OSGI callback for activating this component
 *
 * @param cc//  www  .  ja va 2  s. c o m
 *          the osgi component context
 */
public void activate(ComponentContext cc) throws ConfigurationException {
    logger.info("Static File REST Service started.");
    serverUrl = OsgiUtil.getContextProperty(cc, MatterhornConstants.SERVER_URL_PROPERTY);
    useWebserver = BooleanUtils.toBoolean(
            OsgiUtil.getOptCfg(cc.getProperties(), STATICFILES_WEBSERVER_ENABLED_KEY).getOrElse("false"));
    webserverURL = OsgiUtil.getOptCfg(cc.getProperties(), STATICFILES_WEBSERVER_URL_KEY);

    Option<String> cfgMaxUploadSize = OsgiUtil.getOptContextProperty(cc, STATICFILES_UPLOAD_MAX_SIZE_KEY);
    if (cfgMaxUploadSize.isSome())
        maxUploadSize = Long.parseLong(cfgMaxUploadSize.get());
}

---

From source file:org.opencastproject.workflow.handler.AnalyzeAudioWorkflowOperationHandler.java

private WorkflowOperationResult analyze(MediaPackage src, WorkflowOperationInstance operation)
        throws SoxException, IOException, NotFoundException, MediaPackageException, WorkflowOperationException,
        EncoderException {/* w  w  w.j av a  2s.  c om*/
    MediaPackage mediaPackage = (MediaPackage) src.clone();

    // Check which tags have been configured
    String sourceTagsOption = StringUtils.trimToNull(operation.getConfiguration("source-tags"));
    String sourceFlavorOption = StringUtils.trimToNull(operation.getConfiguration("source-flavor"));
    String sourceFlavorsOption = StringUtils.trimToNull(operation.getConfiguration("source-flavors"));
    boolean forceTranscode = BooleanUtils.toBoolean(operation.getConfiguration("force-transcode"));

    AbstractMediaPackageElementSelector<Track> elementSelector = new TrackSelector();

    // Make sure either one of tags or flavors are provided
    if (StringUtils.isBlank(sourceTagsOption) && StringUtils.isBlank(sourceFlavorOption)
            && StringUtils.isBlank(sourceFlavorsOption)) {
        logger.info("No source tags or flavors have been specified, not matching anything");
        return createResult(mediaPackage, Action.CONTINUE);
    }

    // Select the source flavors
    for (String flavor : asList(sourceFlavorsOption)) {
        try {
            elementSelector.addFlavor(MediaPackageElementFlavor.parseFlavor(flavor));
        } catch (IllegalArgumentException e) {
            throw new WorkflowOperationException("Source flavor '" + flavor + "' is malformed");
        }
    }

    // Support legacy "source-flavor" option
    if (StringUtils.isNotBlank(sourceFlavorOption)) {
        String flavor = StringUtils.trim(sourceFlavorOption);
        try {
            elementSelector.addFlavor(MediaPackageElementFlavor.parseFlavor(flavor));
        } catch (IllegalArgumentException e) {
            throw new WorkflowOperationException("Source flavor '" + flavor + "' is malformed");
        }
    }

    // Select the source tags
    for (String tag : asList(sourceTagsOption)) {
        elementSelector.addTag(tag);
    }

    // Look for elements matching the tag
    Collection<Track> elements = elementSelector.select(mediaPackage, false);

    // Analyze audio for all tracks found
    long totalTimeInQueue = 0;
    List<URI> cleanupURIs = new ArrayList<URI>();
    Map<Job, Track> analyzeJobs = new HashMap<Job, Track>();
    try {
        for (Track track : elements) {

            TrackImpl audioTrack = (TrackImpl) track;
            // Skip video only mismatches
            if (!track.hasAudio()) {
                logger.info("Skipping audio analysis of '{}', since it contains no audio stream", track);
                continue;
            } else if (track.hasVideo() || forceTranscode) {
                audioTrack = (TrackImpl) extractAudioTrack(track);
                audioTrack.setAudio(((TrackImpl) track).getAudio());
                cleanupURIs.add(audioTrack.getURI());
            }

            analyzeJobs.put(soxService.analyze(audioTrack), track);
        }

        if (analyzeJobs.isEmpty()) {
            logger.info("No matching tracks found");
            return createResult(mediaPackage, Action.CONTINUE);
        }

        // Wait for the jobs to return
        if (!waitForStatus(analyzeJobs.keySet().toArray(new Job[analyzeJobs.size()])).isSuccess())
            throw new WorkflowOperationException("One of the analyze jobs did not complete successfully");

        // Process the result
        for (Map.Entry<Job, Track> entry : analyzeJobs.entrySet()) {
            Job job = entry.getKey();
            TrackImpl origTrack = (TrackImpl) entry.getValue();

            // add this receipt's queue time to the total
            totalTimeInQueue += job.getQueueTime();

            if (job.getPayload().length() > 0) {
                TrackImpl analyzed = (TrackImpl) MediaPackageElementParser.getFromXml(job.getPayload());

                // Set metadata on track
                origTrack.setAudio(analyzed.getAudio());
            } else {
                logger.warn("Analyze audio job {} for track {} has no result!", job, origTrack);
            }
        }
    } finally {
        // Clean up temporary audio files from workspace
        for (URI uri : cleanupURIs) {
            workspace.delete(uri);
        }
    }

    WorkflowOperationResult result = createResult(mediaPackage, Action.CONTINUE, totalTimeInQueue);
    logger.debug("Analyze audio operation completed");
    return result;
}

---

From source file:org.opencastproject.workflow.handler.CleanupWorkflowOperationHandler.java

/**
 * {@inheritDoc}/*from   w  w w  .  ja v  a 2  s  . c o m*/
 * 
 * @see org.opencastproject.workflow.api.AbstractWorkflowOperationHandler#start(org.opencastproject.workflow.api.WorkflowInstance,
 *      JobContext)
 */
@Override
public WorkflowOperationResult start(WorkflowInstance workflowInstance, JobContext context)
        throws WorkflowOperationException {
    MediaPackage mediaPackage = workflowInstance.getMediaPackage();
    WorkflowOperationInstance currentOperation = workflowInstance.getCurrentOperation();

    String flavors = currentOperation.getConfiguration(PRESERVE_FLAVOR_PROPERTY);
    final List<MediaPackageElementFlavor> flavorsToPreserve = new ArrayList<MediaPackageElementFlavor>();

    boolean deleteExternal = BooleanUtils.toBoolean(currentOperation.getConfiguration(DELETE_EXTERNAL));

    // If the configuration does not specify flavors, remove them all
    for (String flavor : asList(flavors)) {
        flavorsToPreserve.add(MediaPackageElementFlavor.parseFlavor(flavor));
    }

    String baseUrl = workspace.getBaseUri().toString();

    // Find all external working file repository base Urls
    List<String> externalWfrBaseUrls = new ArrayList<String>();
    if (deleteExternal) {
        try {
            for (ServiceRegistration reg : serviceRegistry
                    .getServiceRegistrationsByType(WorkingFileRepository.SERVICE_TYPE)) {
                if (baseUrl.startsWith(reg.getHost()))
                    continue;
                externalWfrBaseUrls.add(UrlSupport.concat(reg.getHost(), reg.getPath()));
            }
        } catch (ServiceRegistryException e) {
            logger.error("Unable to load WFR services from service registry: {}", e.getMessage());
            throw new WorkflowOperationException(e);
        }
    }

    // Some URIs are shared by multiple elements. If one of these elements should be deleted but another should not, we
    // must keep the file.
    Set<URI> urisToDelete = new HashSet<URI>();
    Set<URI> urisToKeep = new HashSet<URI>();
    for (MediaPackageElement element : mediaPackage.getElements()) {
        if (element.getURI() == null)
            continue;

        String elementUri = element.getURI().toString();
        if (!elementUri.startsWith(baseUrl)) {
            if (deleteExternal) {

                String wfrBaseUrl = null;
                for (String url : externalWfrBaseUrls) {
                    if (element.getURI().toString().startsWith(url)) {
                        wfrBaseUrl = url;
                        break;
                    }
                }
                if (wfrBaseUrl == null)
                    continue;

                HttpDelete delete;
                if (elementUri.startsWith(
                        UrlSupport.concat(wfrBaseUrl, WorkingFileRepository.MEDIAPACKAGE_PATH_PREFIX))) {
                    String wfrDeleteUrl = elementUri.substring(0, elementUri.lastIndexOf("/"));
                    delete = new HttpDelete(wfrDeleteUrl);
                } else if (elementUri.startsWith(
                        UrlSupport.concat(wfrBaseUrl, WorkingFileRepository.COLLECTION_PATH_PREFIX))) {
                    delete = new HttpDelete(elementUri);
                } else {
                    logger.info("Unable to handle URI {}", elementUri);
                    continue;
                }

                try {
                    HttpResponse response = client.execute(delete);
                    int statusCode = response.getStatusLine().getStatusCode();
                    if (statusCode == HttpStatus.SC_NO_CONTENT || statusCode == HttpStatus.SC_OK) {
                        logger.info("Sucessfully deleted external URI {}", delete.getURI());
                    } else if (statusCode == HttpStatus.SC_NOT_FOUND) {
                        logger.info("External URI {} has already been deleted", delete.getURI());
                    } else {
                        logger.info("Unable to delete external URI {}, status code '{}' returned",
                                delete.getURI(), statusCode);
                    }
                } catch (TrustedHttpClientException e) {
                    logger.warn("Unable to execute DELETE request on external URI {}", delete.getURI());
                    throw new WorkflowOperationException(e);
                }
            }
            continue;
        }

        // remove the element if it doesn't match the flavors to preserve
        boolean remove = true;
        for (MediaPackageElementFlavor flavor : flavorsToPreserve) {
            if (flavor.matches(element.getFlavor())) {
                remove = false;
                break;
            }
        }
        if (remove) {
            urisToDelete.add(element.getURI());
            mediaPackage.remove(element);
        } else {
            urisToKeep.add(element.getURI());
        }
    }

    // Remove all of the files to keep from the one to delete
    urisToDelete.removeAll(urisToKeep);

    // Now remove the files to delete
    for (URI uri : urisToDelete) {
        try {
            workspace.delete(uri);
        } catch (Exception e) {
            logger.warn("Unable to delete {}", uri);
        }
    }
    return createResult(mediaPackage, Action.CONTINUE);
}

---

From source file:org.opencastproject.workflow.handler.ingest.IngestDownloadWorkflowOperationHandler.java

/**
 * {@inheritDoc}/*from   w  w w.  j a  v a 2 s . c  om*/
 *
 * @see org.opencastproject.workflow.api.AbstractWorkflowOperationHandler#start(org.opencastproject.workflow.api.WorkflowInstance,
 *      JobContext)
 */
@Override
public WorkflowOperationResult start(WorkflowInstance workflowInstance, JobContext context)
        throws WorkflowOperationException {
    MediaPackage mediaPackage = workflowInstance.getMediaPackage();
    WorkflowOperationInstance currentOperation = workflowInstance.getCurrentOperation();

    boolean deleteExternal = BooleanUtils.toBoolean(currentOperation.getConfiguration(DELETE_EXTERNAL));

    String baseUrl = workspace.getBaseUri().toString();

    List<URI> externalUris = new ArrayList<URI>();
    for (MediaPackageElement element : mediaPackage.getElements()) {
        if (element.getURI() == null)
            continue;

        URI originalElementUri = element.getURI();
        if (originalElementUri.toString().startsWith(baseUrl)) {
            logger.info("Skipping downloading already existing element {}", originalElementUri);
            continue;
        }

        // Download the external URI
        File file;
        try {
            file = workspace.get(element.getURI());
        } catch (Exception e) {
            logger.warn("Unable to download the external element {}", element.getURI());
            throw new WorkflowOperationException("Unable to download the external element " + element.getURI(),
                    e);
        }

        // Put to working file repository and rewrite URI on element
        InputStream in = null;
        try {
            in = new FileInputStream(file);
            URI uri = workspace.put(mediaPackage.getIdentifier().compact(), element.getIdentifier(),
                    FilenameUtils.getName(element.getURI().getPath()), in);
            element.setURI(uri);
        } catch (Exception e) {
            logger.warn("Unable to store downloaded element '{}': {}", element.getURI(), e.getMessage());
            throw new WorkflowOperationException("Unable to store downloaded element " + element.getURI(), e);
        } finally {
            IOUtils.closeQuietly(in);
            try {
                workspace.delete(originalElementUri);
            } catch (Exception e) {
                logger.warn("Unable to delete ingest-downloaded element {}: {}", element.getURI(), e);
            }
        }

        logger.info("Downloaded the external element {}", originalElementUri);

        // Store origianl URI for deletion
        externalUris.add(originalElementUri);
    }

    if (!deleteExternal || externalUris.size() == 0)
        return createResult(mediaPackage, Action.CONTINUE);

    // Find all external working file repository base Urls
    logger.debug("Assembling list of external working file repositories");
    List<String> externalWfrBaseUrls = new ArrayList<String>();
    try {
        for (ServiceRegistration reg : serviceRegistry
                .getServiceRegistrationsByType(WorkingFileRepository.SERVICE_TYPE)) {
            if (baseUrl.startsWith(reg.getHost())) {
                logger.trace("Skpping local working file repository");
                continue;
            }
            externalWfrBaseUrls.add(UrlSupport.concat(reg.getHost(), reg.getPath()));
        }
        logger.debug("{} external working file repositories found", externalWfrBaseUrls.size());
    } catch (ServiceRegistryException e) {
        logger.error("Unable to load WFR services from service registry: {}", e.getMessage());
        throw new WorkflowOperationException(e);
    }

    for (URI uri : externalUris) {

        String elementUri = uri.toString();

        // Delete external working file repository URI's
        String wfrBaseUrl = null;
        for (String url : externalWfrBaseUrls) {
            if (elementUri.startsWith(url)) {
                wfrBaseUrl = url;
                break;
            }
        }

        if (wfrBaseUrl == null) {
            logger.info("Unable to delete external URI {}, no working file repository found", elementUri);
            continue;
        }

        HttpDelete delete;
        if (elementUri
                .startsWith(UrlSupport.concat(wfrBaseUrl, WorkingFileRepository.MEDIAPACKAGE_PATH_PREFIX))) {
            String wfrDeleteUrl = elementUri.substring(0, elementUri.lastIndexOf("/"));
            delete = new HttpDelete(wfrDeleteUrl);
        } else if (elementUri
                .startsWith(UrlSupport.concat(wfrBaseUrl, WorkingFileRepository.COLLECTION_PATH_PREFIX))) {
            delete = new HttpDelete(elementUri);
        } else {
            logger.info("Unable to handle working file repository URI {}", elementUri);
            continue;
        }

        HttpResponse response = null;
        try {
            response = client.execute(delete);
            int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode == HttpStatus.SC_NO_CONTENT || statusCode == HttpStatus.SC_OK) {
                logger.info("Sucessfully deleted external URI {}", delete.getURI());
            } else if (statusCode == HttpStatus.SC_NOT_FOUND) {
                logger.info("External URI {} has already been deleted", delete.getURI());
            } else {
                logger.info("Unable to delete external URI {}, status code '{}' returned", delete.getURI(),
                        statusCode);
            }
        } catch (TrustedHttpClientException e) {
            logger.warn("Unable to execute DELETE request on external URI {}", delete.getURI());
            throw new WorkflowOperationException(e);
        } finally {
            client.close(response);
        }
    }

    return createResult(mediaPackage, Action.CONTINUE);
}

---

From source file:org.opencastproject.workflow.handler.IngestDownloadWorkflowOperationHandler.java

/**
 * {@inheritDoc}/*w  w  w  .  j  a  v a2s.  c  om*/
 * 
 * @see org.opencastproject.workflow.api.AbstractWorkflowOperationHandler#start(org.opencastproject.workflow.api.WorkflowInstance,
 *      JobContext)
 */
@Override
public WorkflowOperationResult start(WorkflowInstance workflowInstance, JobContext context)
        throws WorkflowOperationException {
    MediaPackage mediaPackage = workflowInstance.getMediaPackage();
    WorkflowOperationInstance currentOperation = workflowInstance.getCurrentOperation();

    boolean deleteExternal = BooleanUtils.toBoolean(currentOperation.getConfiguration(DELETE_EXTERNAL));

    String baseUrl = workspace.getBaseUri().toString();

    List<URI> externalUris = new ArrayList<URI>();
    for (MediaPackageElement element : mediaPackage.getElements()) {
        if (element.getURI() == null)
            continue;

        URI originalElementUri = element.getURI();
        if (originalElementUri.toString().startsWith(baseUrl)) {
            logger.info("Skipping downloading already existing element {}", originalElementUri);
            continue;
        }

        // Download the external URI
        File file;
        try {
            file = workspace.get(element.getURI());
        } catch (Exception e) {
            logger.warn("Unable to download the external element {}", element.getURI());
            throw new WorkflowOperationException("Unable to download the external element " + element.getURI(),
                    e);
        }

        // Put to working file repository and rewrite URI on element
        InputStream in = null;
        try {
            in = new FileInputStream(file);
            URI uri = workspace.put(mediaPackage.getIdentifier().compact(), element.getIdentifier(),
                    FilenameUtils.getName(element.getURI().getPath()), in);
            element.setURI(uri);
        } catch (Exception e) {
            logger.warn("Unable to store downloaded element '{}': {}", element.getURI(), e.getMessage());
            throw new WorkflowOperationException("Unable to store downloaded element " + element.getURI(), e);
        } finally {
            IOUtils.closeQuietly(in);
            try {
                workspace.delete(originalElementUri);
            } catch (Exception e) {
                logger.warn("Unable to delete ingest-downloaded element {}: {}", element.getURI(), e);
            }
        }

        logger.info("Downloaded the external element {}", originalElementUri);

        // Store origianl URI for deletion
        externalUris.add(originalElementUri);
    }

    if (!deleteExternal || externalUris.size() == 0)
        return createResult(mediaPackage, Action.CONTINUE);

    // Find all external working file repository base Urls
    logger.debug("Assembling list of external working file repositories");
    List<String> externalWfrBaseUrls = new ArrayList<String>();
    try {
        for (ServiceRegistration reg : serviceRegistry
                .getServiceRegistrationsByType(WorkingFileRepository.SERVICE_TYPE)) {
            if (baseUrl.startsWith(reg.getHost())) {
                logger.trace("Skpping local working file repository");
                continue;
            }
            externalWfrBaseUrls.add(UrlSupport.concat(reg.getHost(), reg.getPath()));
        }
        logger.debug("{} external working file repositories found", externalWfrBaseUrls.size());
    } catch (ServiceRegistryException e) {
        logger.error("Unable to load WFR services from service registry: {}", e.getMessage());
        throw new WorkflowOperationException(e);
    }

    for (URI uri : externalUris) {

        String elementUri = uri.toString();

        // Delete external working file repository URI's
        String wfrBaseUrl = null;
        for (String url : externalWfrBaseUrls) {
            if (elementUri.startsWith(url)) {
                wfrBaseUrl = url;
                break;
            }
        }

        if (wfrBaseUrl == null) {
            logger.info("Unable to delete external URI {}, no working file repository found", elementUri);
            continue;
        }

        HttpDelete delete;
        if (elementUri
                .startsWith(UrlSupport.concat(wfrBaseUrl, WorkingFileRepository.MEDIAPACKAGE_PATH_PREFIX))) {
            String wfrDeleteUrl = elementUri.substring(0, elementUri.lastIndexOf("/"));
            delete = new HttpDelete(wfrDeleteUrl);
        } else if (elementUri
                .startsWith(UrlSupport.concat(wfrBaseUrl, WorkingFileRepository.COLLECTION_PATH_PREFIX))) {
            delete = new HttpDelete(elementUri);
        } else {
            logger.info("Unable to handle working file repository URI {}", elementUri);
            continue;
        }

        try {
            HttpResponse response = client.execute(delete);
            int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode == HttpStatus.SC_NO_CONTENT || statusCode == HttpStatus.SC_OK) {
                logger.info("Sucessfully deleted external URI {}", delete.getURI());
            } else if (statusCode == HttpStatus.SC_NOT_FOUND) {
                logger.info("External URI {} has already been deleted", delete.getURI());
            } else {
                logger.info("Unable to delete external URI {}, status code '{}' returned", delete.getURI(),
                        statusCode);
            }
        } catch (TrustedHttpClientException e) {
            logger.warn("Unable to execute DELETE request on external URI {}", delete.getURI());
            throw new WorkflowOperationException(e);
        }
    }

    return createResult(mediaPackage, Action.CONTINUE);
}

---

From source file:org.opencastproject.workflow.handler.NormalizeAudioWorkflowOperationHandler.java

private WorkflowOperationResult normalize(MediaPackage src, WorkflowOperationInstance operation)
        throws SoxException, IOException, NotFoundException, MediaPackageException, WorkflowOperationException,
        EncoderException {//from   www  .  j  ava2  s .  com
    MediaPackage mediaPackage = (MediaPackage) src.clone();

    // Check which tags have been configured
    String sourceTagsOption = StringUtils.trimToNull(operation.getConfiguration("source-tags"));
    String targetTagsOption = StringUtils.trimToNull(operation.getConfiguration("target-tags"));
    String sourceFlavorOption = StringUtils.trimToNull(operation.getConfiguration("source-flavor"));
    String sourceFlavorsOption = StringUtils.trimToNull(operation.getConfiguration("source-flavors"));
    String targetFlavorOption = StringUtils.trimToNull(operation.getConfiguration("target-flavor"));
    String targetDecibelString = StringUtils.trimToNull(operation.getConfiguration("target-decibel"));
    if (targetDecibelString == null)
        throw new IllegalArgumentException("target-decibel must be specified");
    boolean forceTranscode = BooleanUtils.toBoolean(operation.getConfiguration("force-transcode"));
    Float targetDecibel;
    try {
        targetDecibel = new Float(targetDecibelString);
    } catch (NumberFormatException e1) {
        throw new WorkflowOperationException("Unable to parse target-decibel " + targetDecibelString);
    }

    AbstractMediaPackageElementSelector<Track> elementSelector = new TrackSelector();

    // Make sure either one of tags or flavors are provided
    if (StringUtils.isBlank(sourceTagsOption) && StringUtils.isBlank(sourceFlavorOption)
            && StringUtils.isBlank(sourceFlavorsOption)) {
        logger.info("No source tags or flavors have been specified, not matching anything");
        return createResult(mediaPackage, Action.CONTINUE);
    }

    // Select the source flavors
    for (String flavor : asList(sourceFlavorsOption)) {
        try {
            elementSelector.addFlavor(MediaPackageElementFlavor.parseFlavor(flavor));
        } catch (IllegalArgumentException e) {
            throw new WorkflowOperationException("Source flavor '" + flavor + "' is malformed");
        }
    }

    // Support legacy "source-flavor" option
    if (StringUtils.isNotBlank(sourceFlavorOption)) {
        String flavor = StringUtils.trim(sourceFlavorOption);
        try {
            elementSelector.addFlavor(MediaPackageElementFlavor.parseFlavor(flavor));
        } catch (IllegalArgumentException e) {
            throw new WorkflowOperationException("Source flavor '" + flavor + "' is malformed");
        }
    }

    // Select the source tags
    for (String tag : asList(sourceTagsOption)) {
        elementSelector.addTag(tag);
    }

    // Target tags
    List<String> targetTags = asList(targetTagsOption);

    // Target flavor
    MediaPackageElementFlavor targetFlavor = null;
    if (StringUtils.isNotBlank(targetFlavorOption)) {
        try {
            targetFlavor = MediaPackageElementFlavor.parseFlavor(targetFlavorOption);
        } catch (IllegalArgumentException e) {
            throw new WorkflowOperationException("Target flavor '" + targetFlavorOption + "' is malformed");
        }
    }

    // Look for elements matching the tag
    Collection<Track> elements = elementSelector.select(mediaPackage, false);

    // Encode all tracks found
    long totalTimeInQueue = 0;
    List<URI> cleanupURIs = new ArrayList<URI>();
    Map<Job, Track> normalizeJobs = new HashMap<Job, Track>();
    try {
        for (Track track : elements) {

            TrackImpl audioTrack = (TrackImpl) track;
            // Skip video only mismatches
            if (!track.hasAudio()) {
                logger.info("Skipping audio normalization of '{}', since it contains no audio stream", track);
                continue;
            } else if (track.hasVideo() || forceTranscode) {
                audioTrack = (TrackImpl) extractAudioTrack(track);
                audioTrack.setAudio(((TrackImpl) track).getAudio());
                cleanupURIs.add(audioTrack.getURI());
            }

            // Analyze audio track
            if (audioTrack.getAudio().size() < 1 || audioTrack.getAudio().get(0).getRmsLevDb() == null) {
                logger.info("Audio track {} has no RMS Lev dB metadata, analyze it first", audioTrack);
                Job analyzeJob = soxService.analyze(audioTrack);
                if (!waitForStatus(analyzeJob).isSuccess())
                    throw new WorkflowOperationException("Unable to analyze the audio track " + audioTrack);
                audioTrack = (TrackImpl) MediaPackageElementParser.getFromXml(analyzeJob.getPayload());
                cleanupURIs.add(audioTrack.getURI());
            }

            normalizeJobs.put(soxService.normalize(audioTrack, targetDecibel), track);
        }

        if (normalizeJobs.isEmpty()) {
            logger.info("No matching tracks found");
            return createResult(mediaPackage, Action.CONTINUE);
        }

        // Wait for the jobs to return
        if (!waitForStatus(normalizeJobs.keySet().toArray(new Job[normalizeJobs.size()])).isSuccess())
            throw new WorkflowOperationException("One of the normalize jobs did not complete successfully");

        // Process the result
        for (Map.Entry<Job, Track> entry : normalizeJobs.entrySet()) {
            Job job = entry.getKey();
            TrackImpl origTrack = (TrackImpl) entry.getValue();

            // add this receipt's queue time to the total
            totalTimeInQueue += job.getQueueTime();

            if (job.getPayload().length() > 0) {
                TrackImpl normalizedAudioTrack = (TrackImpl) MediaPackageElementParser
                        .getFromXml(job.getPayload());

                TrackImpl resultTrack = normalizedAudioTrack;
                if (origTrack.hasVideo() || forceTranscode) {
                    cleanupURIs.add(normalizedAudioTrack.getURI());

                    logger.info("Mux normalized audio track {} to video track {}", normalizedAudioTrack,
                            origTrack);
                    Job muxAudioVideo = composerService.mux(origTrack, normalizedAudioTrack,
                            SOX_AREPLACE_PROFILE);
                    if (!waitForStatus(muxAudioVideo).isSuccess())
                        throw new WorkflowOperationException("Muxing normalized audio track "
                                + normalizedAudioTrack + " to video container " + origTrack + " failed");

                    resultTrack = (TrackImpl) MediaPackageElementParser.getFromXml(muxAudioVideo.getPayload());

                    // Set metadata on track
                    extendAudioStream(resultTrack, normalizedAudioTrack);
                }

                adjustFlavorAndTags(targetTags, targetFlavor, origTrack, resultTrack);

                mediaPackage.addDerived(resultTrack, origTrack);
                String fileName = getFileNameFromElements(origTrack, resultTrack);
                resultTrack.setURI(workspace.moveTo(resultTrack.getURI(),
                        mediaPackage.getIdentifier().toString(), resultTrack.getIdentifier(), fileName));
            } else {
                logger.warn("Normalize audio job {} for track {} has no result!", job, origTrack);
            }
        }
    } finally {
        // Clean up temporary audio and video files from workspace
        for (URI uri : cleanupURIs) {
            workspace.delete(uri);
        }
    }

    WorkflowOperationResult result = createResult(mediaPackage, Action.CONTINUE, totalTimeInQueue);
    logger.debug("Normalize audio operation completed");
    return result;
}

---

From source file:org.opencastproject.workflow.handler.TagWorkflowOperationHandler.java

/**
 * {@inheritDoc}/*  w ww. j a v a2  s. c o  m*/
 * 
 * @see org.opencastproject.workflow.api.WorkflowOperationHandler#start(org.opencastproject.workflow.api.WorkflowInstance,
 *      JobContext)
 */
@Override
public WorkflowOperationResult start(WorkflowInstance workflowInstance, JobContext context)
        throws WorkflowOperationException {

    MediaPackage mediaPackage = workflowInstance.getMediaPackage();
    WorkflowOperationInstance currentOperation = workflowInstance.getCurrentOperation();

    String configuredSourceFlavors = StringUtils
            .trimToEmpty(currentOperation.getConfiguration(SOURCE_FLAVORS_PROPERTY));
    String configuredSourceTags = StringUtils
            .trimToEmpty(currentOperation.getConfiguration(SOURCE_TAGS_PROPERTY));
    String configuredTargetFlavor = StringUtils
            .trimToNull(currentOperation.getConfiguration(TARGET_FLAVOR_PROPERTY));
    String configuredTargetTags = StringUtils
            .trimToEmpty(currentOperation.getConfiguration(TARGET_TAGS_PROPERTY));
    boolean copy = BooleanUtils.toBoolean(currentOperation.getConfiguration(COPY_PROPERTY));

    if (copy) {
        logger.info("Retagging mediapackage elements as a copy");
    } else {
        logger.info("Retagging mediapackage elements");
    }

    String[] sourceTags = StringUtils.split(configuredSourceTags, ",");
    String[] targetTags = StringUtils.split(configuredTargetTags, ",");
    String[] sourceFlavors = StringUtils.split(configuredSourceFlavors, ",");

    SimpleElementSelector elementSelector = new SimpleElementSelector();
    for (String flavor : sourceFlavors) {
        elementSelector.addFlavor(MediaPackageElementFlavor.parseFlavor(flavor));
    }

    List<String> removeTags = new ArrayList<String>();
    List<String> addTags = new ArrayList<String>();
    List<String> overrideTags = new ArrayList<String>();

    for (String tag : targetTags) {
        if (tag.startsWith(MINUS)) {
            removeTags.add(tag);
        } else if (tag.startsWith(PLUS)) {
            addTags.add(tag);
        } else {
            overrideTags.add(tag);
        }
    }

    for (String tag : sourceTags) {
        elementSelector.addTag(tag);
    }

    Collection<MediaPackageElement> elements = elementSelector.select(mediaPackage, false);
    for (MediaPackageElement e : elements) {
        MediaPackageElement element = e;
        if (copy) {
            element = (MediaPackageElement) e.clone();
            element.setIdentifier(null);
            element.setURI(e.getURI()); // use the same URI as the original
        }
        if (configuredTargetFlavor != null)
            element.setFlavor(MediaPackageElementFlavor.parseFlavor(configuredTargetFlavor));

        if (overrideTags.size() > 0) {
            element.clearTags();
            for (String tag : overrideTags) {
                element.addTag(tag);
            }
        } else {
            for (String tag : removeTags) {
                element.removeTag(tag.substring(MINUS.length()));
            }
            for (String tag : addTags) {
                element.addTag(tag.substring(PLUS.length()));
            }
        }

        if (copy)
            mediaPackage.addDerived(element, e);
    }
    return createResult(mediaPackage, Action.CONTINUE);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• »