eu.prestoprime.plugin.dracma.DRACMATasks.java Source code

Java tutorial

Introduction

Here is the source code for eu.prestoprime.plugin.dracma.DRACMATasks.java

Source

package eu.prestoprime.plugin.dracma;

import it.eurix.archtools.data.DataException;
import it.eurix.archtools.data.model.DIP;
import it.eurix.archtools.data.model.IPException;
import it.eurix.archtools.data.model.SIP;
import it.eurix.archtools.tool.ToolException;
import it.eurix.archtools.tool.ToolOutput;
import it.eurix.archtools.tool.impl.MessageDigestExtractor;
import it.eurix.archtools.workflow.exceptions.TaskExecutionFailedException;
import it.eurix.archtools.workflow.plugin.WfPlugin;
import it.eurix.archtools.workflow.plugin.WfPlugin.WfService;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.List;
import java.util.Map;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.impl.client.DefaultHttpClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import eu.prestoprime.datamanagement.P4DataManager;
import eu.prestoprime.plugin.dracma.client.DRACMAClient;
import eu.prestoprime.plugin.dracma.client.DRACMAException;
import eu.prestoprime.plugin.dracma.client.DRACMASegment;

/**
 * DRACMATasks.java
 * Author: Francesco Rosso (rosso@eurix.it)
 * 
 * This file is part of PrestoPRIME Preservation Platform (P4).
 * 
 * Copyright (C) 2009-2012 EURIX Srl, Torino, Italy
 *  
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

@WfPlugin(name = "DRACMAPlugin")
public class DRACMATasks {

    private static final Logger logger = LoggerFactory.getLogger(DRACMATasks.class);

    @WfService(name = "dracma_indexing", version = "2.0.0")
    public void index(Map<String, String> sParams, Map<String, String> dParamsString, Map<String, File> dParamsFile)
            throws TaskExecutionFailedException {

        if (Boolean.parseBoolean(dParamsString.get("isD10"))) {
            // retrieve dynamic parameters
            String sipID = dParamsString.get("sipID");

            // retrieve static parameters
            String DRACMAIndexServer = sParams.get("dracma.indexing.url");
            String[] MQFormats = sParams.get("MQformats").split(",");

            SIP sip = null;
            try {
                sip = P4DataManager.getInstance().getSIPByID(sipID);

                for (String format : MQFormats) {
                    List<String> MQFilePathList = sip.getAVMaterial(format, "FILE");
                    if (MQFilePathList.size() > 0) {

                        URI indexServer = new URI(DRACMAIndexServer);
                        File mxfFile = new File(MQFilePathList.get(0));

                        String UMID = new DRACMAClient(indexServer).index(mxfFile);

                        MessageDigestExtractor mde = new MessageDigestExtractor();
                        ToolOutput<MessageDigestExtractor.AttributeType> output = mde
                                .extract(mxfFile.getAbsolutePath());

                        sip.addFile(format, "DRACMA", UMID,
                                output.getAttribute(MessageDigestExtractor.AttributeType.MD5), mxfFile.length());

                        break;
                    }
                }

            } catch (DataException e) {
                e.printStackTrace();
                throw new TaskExecutionFailedException("Unable to retrieve the SIP...");
            } catch (IPException e) {
                e.printStackTrace();
                throw new TaskExecutionFailedException("Unable to retrieve the MQ file...");
            } catch (DRACMAException e) {
                e.printStackTrace();
                throw new TaskExecutionFailedException("Unable to execute DRACMA indexing...");
            } catch (ToolException e) {
                e.printStackTrace();
                throw new TaskExecutionFailedException("Unable to compute the MD5...");
            } catch (URISyntaxException e) {
                e.printStackTrace();
                throw new TaskExecutionFailedException("Bad DRACMA indexing URL in wfDescriptor...");
            } finally {
                P4DataManager.getInstance().releaseIP(sip);
            }
        }
    }

    @WfService(name = "dracma_make_consumer_segment", version = "2.0.0")
    public void segment(Map<String, String> sParams, Map<String, String> dParamsString,
            Map<String, File> dParamsFile) throws TaskExecutionFailedException {

        if (!Boolean.parseBoolean(dParamsString.get("isSegmented"))) {

            // retrieve static params
            String DRACMASegmentServer = sParams.get("dracma.segmenter.url");
            String destVolume = sParams.get("dest.path.volume").trim();
            String destFolder = sParams.get("dest.path.folder").trim();

            // retrieve dynamic params
            String dipID = dParamsString.get("dipID");
            String sourceFilePath = dParamsString.get("source.file.path");
            String mimetype = dParamsString.get("source.file.mimetype");
            int startFrame = Integer.parseInt(dParamsString.get("start.frame"));
            int stopFrame = Integer.parseInt(dParamsString.get("stop.frame"));

            String outputFolder = destVolume + File.separator + destFolder;

            try {
                DIP dip = P4DataManager.getInstance().getDIPByID(dipID);

                // get UMID
                String UMID = null;

                if (mimetype != null) {
                    List<String> videoFileList = dip.getAVMaterial(mimetype, "DRACMA");

                    if (videoFileList.size() > 0) {
                        UMID = videoFileList.get(0);

                        File targetDir = new File(outputFolder);
                        targetDir.mkdirs();

                        if (!targetDir.canWrite())
                            throw new TaskExecutionFailedException("Unable to write to output dir " + outputFolder);

                        String targetFileName = dipID + "." + startFrame + "." + stopFrame + ".mxf";
                        File targetFile = new File(targetDir, targetFileName);

                        URI segmentServer = new URI(DRACMASegmentServer);
                        DRACMAClient c = new DRACMAClient(segmentServer);

                        c.update(UMID, new File(sourceFilePath));

                        logger.debug("Updated DRACMA " + UMID + " resource location to " + sourceFilePath);
                        logger.debug("Requesting segment to DRACMA...");

                        DRACMASegment segment = new DRACMASegment(UMID, startFrame, stopFrame);
                        URL targetFileURL = c.segment(segment);

                        logger.debug("DRACMA segmented available on " + targetFileURL);
                        logger.debug("Downloadin' DRACMA segment...");

                        HttpClient client = new DefaultHttpClient();
                        HttpUriRequest request = new HttpGet(targetFileURL.toString());
                        HttpResponse response = client.execute(request);
                        if (response.getStatusLine().getStatusCode() == 200) {
                            HttpEntity entity = response.getEntity();

                            InputStream in = entity.getContent();
                            FileOutputStream out = new FileOutputStream(targetFile);

                            byte[] buffer = new byte[4096];
                            int bytesRead;
                            while ((bytesRead = in.read(buffer)) != -1)
                                out.write(buffer, 0, bytesRead);

                            in.close();
                            out.close();

                            dParamsString.put("isSegmented", "true");
                            dParamsString.put("segment.file.path", targetFileName);

                            logger.debug("Consumer copy available at: " + targetFile.getAbsolutePath());
                        } else {
                            logger.debug(
                                    "DRACMA response with status code " + response.getStatusLine().getStatusCode());
                        }
                    }
                }
            } catch (DataException e) {
                e.printStackTrace();
                throw new TaskExecutionFailedException("Unable to retrieve DIP with id: " + dipID);
            } catch (IPException | FileNotFoundException e) {
                e.printStackTrace();
                throw new TaskExecutionFailedException("Unable to retrieve MQ file");
            } catch (IOException e) {
                e.printStackTrace();
                throw new TaskExecutionFailedException("Unable to create consumer copy");
            } catch (DRACMAException e) {
                e.printStackTrace();
                throw new TaskExecutionFailedException("Unable to execute segmentation with DRACMA...");
            } catch (URISyntaxException e) {
                e.printStackTrace();
                throw new TaskExecutionFailedException("Bad DRACMA segmenter URL in wfDescriptor...");
            }
        }
    }
}