EDIT

import org.apache.http.client.methods.HttpHead;

                throw new HttpException("HTTP GET response " + UriUtils.getStatus(response) + " for " + uri.toString());

        HttpHead httpget = new HttpHead(serviceUri.getJavaUri());

/**

* Copyright (C) 2021 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.api.service.media;

import java.io.IOException;

import java.io.InputStream;

import org.apache.commons.imaging.ImageInfo;

import org.apache.commons.imaging.ImageReadException;

import org.apache.commons.imaging.Imaging;

import org.apache.commons.imaging.common.GenericImageMetadata.GenericImageMetadataItem;

import org.apache.commons.imaging.common.ImageMetadata;

import org.apache.commons.imaging.common.ImageMetadata.ImageMetadataItem;

import org.apache.commons.lang3.StringUtils;

import org.apache.http.HttpException;

import org.apache.http.client.ClientProtocolException;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.common.UriUtils;

/**

 * TODO make use of timeOut ?

 *

 * Most code  was extracted from CdmImageInfo.

 *

 */

public class MediaMetadataFileReader extends AbstactMediaMetadataReader {

    private static Logger logger = Logger.getLogger(MediaMetadataFileReader.class);

    public static final Integer IMAGE_READ_TIMEOUT = 3000; // ms

    private Integer timeOut = IMAGE_READ_TIMEOUT; // setting default

    /**

     * The <code>MediaMetadataFileReader</code> should not be used directly this method

     * only exists for not to break legacy code.

     * <p>

     * Instead the {@link IMediaInfoFactory} should always be used for to allow

     * all application parts to benefit from the potential speed up through the

     * MediaMetadataService or other fast source of metadata.

     */

    @Deprecated

    public static MediaMetadataFileReader legacyFactoryMethod(eu.etaxonomy.cdm.common.URI uri) {

        return new MediaMetadataFileReader(uri);

    }

    protected MediaMetadataFileReader(eu.etaxonomy.cdm.common.URI uri) {

        super(uri, uri);

    }

    @Override

    public MediaMetadataFileReader read() throws IOException, HttpException {

        return readBaseInfo().readMetaData();

    }

    /**

     * Combines the calls to:

     *

     * <ul>

     * <li>{@link #readImageInfo()}</li>

     * <li>{@link #readImageLength()}</li>

     * <li>{@link #readSuffix()}</li>

     * </ul>

     * to read the commonly needed base information.

     *

     * @return

     * @throws IOException

     * @throws HttpException

     */

    public MediaMetadataFileReader readBaseInfo() throws IOException, HttpException{

        readImageInfo();

        readImageLength();

        readSuffix();

        return this;

    }

    /**

     * Reads the image info (width, height, bitPerPixel, metadata, format, mime type)

     */

    public MediaMetadataFileReader readImageInfo() throws IOException, HttpException{

        InputStream inputStream;

        try {

            inputStream = UriUtils.getInputStream(cdmImageInfo.getUri());

            ImageInfo imageInfo = Imaging.getImageInfo(inputStream, null);

            cdmImageInfo.setFormatName(imageInfo.getFormatName());

            cdmImageInfo.setMimeType(imageInfo.getMimeType());

            cdmImageInfo.setWidth(imageInfo.getWidth());

            cdmImageInfo.setHeight(imageInfo.getHeight());

            cdmImageInfo.setBitPerPixel(imageInfo.getBitsPerPixel());

            inputStream.close();

        } catch (ImageReadException e) {

            logger.error("Could not read: " + cdmImageInfo.getUri() + ". " + e.getMessage());

            throw new IOException(e);

        }

        return this;

    }

    public MediaMetadataFileReader readMetaData() throws IOException, HttpException {

        ImageMetadata mediaData = null;

        try {

            InputStream inputStream = UriUtils.getInputStream(cdmImageInfo.getUri());

            mediaData = Imaging.getMetadata(inputStream, null);

        }catch (ImageReadException e) {

            logger.error("Could not read: " + cdmImageInfo.getUri() + ". " + e.getMessage());

            //throw new IOException(e);

        }

        if(mediaData != null) {

            for (ImageMetadataItem imItem : mediaData.getItems()){

                if (imItem instanceof GenericImageMetadataItem){

                    GenericImageMetadataItem item = (GenericImageMetadataItem)imItem;

                    if ("Keywords".equals(item.getKeyword())){

                        String value = text(item);

                        String[] splits = value.split(":");

                        if (splits.length == 2){

                            //convention used e.g. for Flora of cyprus (#9137)

                            cdmImageInfo.getMetaData().put(splits[0].trim(), splits[1].trim());

                        }else{

                            cdmImageInfo.getMetaData().put(

                                    item.getKeyword(),

                                    CdmUtils.concat("; ", cdmImageInfo.getMetaData().get(item.getKeyword()), value)

                                    );

                        }

                    }else if (item.getKeyword().contains("/")){

                        //TODO: not sure where this syntax is used originally

                        String key = item.getKeyword();

                        //key.replace("/", "");

                        int index = key.indexOf("/");

                        key = key.substring(0, index);

                        cdmImageInfo.getMetaData().put(key, text(item));

                    }else{

                        cdmImageInfo.getMetaData().put(item.getKeyword(), text(item));

                    }

                }

            }

        }

        return this;

    }

    /**

     * Reads the size of the image defined by the {@link #imageUri} in bytes

     */

    public MediaMetadataFileReader readImageLength() throws ClientProtocolException, IOException, HttpException{

        try {

            long length = UriUtils.getResourceLength(cdmImageInfo.getUri(), null);

            cdmImageInfo.setLength(length);

        } catch (HttpException e) {

            if (e.getMessage().equals("Could not retrieve Content-Length")){

                InputStream inputStream = UriUtils.getInputStream(cdmImageInfo.getUri());

                int n = 0;

                while(inputStream.read() != -1){

                    n++;

                }

                inputStream.close();

                logger.info("Content-Length not available in http header. Image size computed via input stream size: " + cdmImageInfo.getUri());

                cdmImageInfo.setLength(n);

            }else{

                throw e;

            }

        }

        return this;

    }

    public MediaMetadataFileReader readSuffix(){

        String path = cdmImageInfo.getUri().getPath();

        String suffix = path.substring(StringUtils.lastIndexOf(path, '.') + 1);

        cdmImageInfo.setSuffix(suffix);

        return this;

    }

}

/**

 *

 */

package eu.etaxonomy.cdm.api.service.media;

import static org.junit.Assert.fail;

import java.io.IOException;

import java.net.URL;

import java.util.Map;

import org.apache.http.HttpException;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

import eu.etaxonomy.cdm.common.URI;

import eu.etaxonomy.cdm.common.UriUtils;

import eu.etaxonomy.cdm.common.media.CdmImageInfo;

import eu.etaxonomy.cdm.common.media.MimeType;

/**

 * @author n.hoffmann

 */

public class MediaMetadataFileReaderTest {

    private static final String OFFLINE = "OFFLINE";

    public static final Logger logger = Logger.getLogger(MediaMetadataFileReaderTest.class);

    private URI jpegUri;

    private URI tiffUri;

    private CdmImageInfo jpegInstance;

    private CdmImageInfo tifInstance;

    private URI remotePngUri;

    private CdmImageInfo pngInstance;

    @Before

    public void setUp() throws Exception {

        URL jpegUrl = MediaMetadataFileReaderTest.class.getResource("./images/OregonScientificDS6639-DSC_0307-small.jpg");

        jpegUri = new URI(jpegUrl);

        URL tiffUrl = MediaMetadataFileReaderTest.class.getResource("./images/OregonScientificDS6639-DSC_0307-small.tif");

        tiffUri = new URI(tiffUrl);

        remotePngUri = URI.create("https://dev.e-taxonomy.eu/trac_htdocs/logo_edit.png");

    }

    @Test

    public void testNewInstanceJpeg(){

        try {

            new MediaMetadataFileReader(jpegUri).readBaseInfo();

        } catch (Exception e) {

            fail("NewInstance method should not throw exceptions for existing uncorrupted images.");

        }

    }

    @Test

    public void testNewInstanceTiff() {

        try {

            new MediaMetadataFileReader(tiffUri).readBaseInfo();

        } catch (Exception e) {

            fail("NewInstance method should not throw exceptions for existing uncorrupted images.");

        }

    }

    @Test

    public void testNewInstanceRemotePng() {

        if(UriUtils.isInternetAvailable(remotePngUri)){

            try {

                new MediaMetadataFileReader(remotePngUri).readBaseInfo();

            } catch (Exception e) {

                fail("NewInstance method should not throw exceptions for existing uncorrupted images.");

            }

        } else {

            logger.warn("test testNewInstanceRemotePng() skipped, since server is not available");

        }

    }

    @Test(expected=IOException.class)

    public void testNewInstanceFileDoesNotExist() throws HttpException, IOException {

        URI nonExistentUri = URI.create("file:///nonExistentImage.jpg");

        new MediaMetadataFileReader(nonExistentUri).readBaseInfo();

    }

    private CdmImageInfo getJpegInstance(){

        if(jpegInstance == null){

            try {

                jpegInstance =  new MediaMetadataFileReader(jpegUri).readBaseInfo().getCdmImageInfo();

            } catch (Exception e) {

                fail("This case should have been covered by other tests.");

                return null;

            }

        }

        return jpegInstance;

    }

    private CdmImageInfo getTifInstance(){

        if(tifInstance == null){

            try {

                tifInstance = new MediaMetadataFileReader(tiffUri).readBaseInfo().getCdmImageInfo();

            } catch (Exception e) {

                fail("This case should have been covered by other tests.");

                return null;

            }

        }

        return tifInstance;

    }

    private CdmImageInfo getRemotePngBaseInfo() throws IOException{

        if (!UriUtils.isInternetAvailable(remotePngUri)){

            throw new IOException(OFFLINE);

        }

        if(pngInstance == null){

            try {

                pngInstance = new MediaMetadataFileReader(remotePngUri).readBaseInfo().getCdmImageInfo();

            } catch (Exception e) {

                fail("This case should have been covered by other tests.");

                return null;

            }

        }

        return pngInstance;

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.common.media.CdmImageInfo#getWidth()}.

     */

    @Test

    public void testGetWidth() {

        Assert.assertEquals(300, getJpegInstance().getWidth());

        Assert.assertEquals(300, getTifInstance().getWidth());

        try {

            Assert.assertEquals(93, getRemotePngBaseInfo().getWidth());

        } catch (IOException e){

            if(e.getMessage().equals(OFFLINE)){

                logger.warn("test part skipped, since server is not available.");

            }

        }

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.common.media.CdmImageInfo#getHeight()}.

     */

    @Test

    public void testGetHeight() {

        Assert.assertEquals(225, getJpegInstance().getHeight());

        Assert.assertEquals(225, getTifInstance().getHeight());

        try {

            Assert.assertEquals(93, getRemotePngBaseInfo().getHeight());

        } catch (IOException e){

            if(e.getMessage().equals(OFFLINE)){

                logger.warn("test part skipped, since server is not available.");

            }

        }

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.common.media.CdmImageInfo#getBitPerPixel()}.

     */

    @Test

    public void testGetBitPerPixel() {

        Assert.assertEquals(24, getJpegInstance().getBitPerPixel());

        Assert.assertEquals(24, getTifInstance().getBitPerPixel());

        try {

            Assert.assertEquals(32, getRemotePngBaseInfo().getBitPerPixel());

        } catch (IOException e){

            if(e.getMessage().equals(OFFLINE)){

                logger.warn("test part skipped, since server is not available.");

            }

        }

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.common.media.CdmImageInfo#getFormatName()}.

     */

    @Test

    public void testGetFormatName() {

        Assert.assertEquals("JPEG (Joint Photographic Experts Group) Format", getJpegInstance().getFormatName());

        Assert.assertEquals("TIFF Tag-based Image File Format", getTifInstance().getFormatName());

        try {

            Assert.assertEquals("PNG Portable Network Graphics", getRemotePngBaseInfo().getFormatName());

        } catch (IOException e){

            if(e.getMessage().equals(OFFLINE)){

                logger.warn("test part skipped, since server is not available.");

            }

        }

    }

    /**

     * Test method for {@link eu.etaxonomy.cdm.common.media.CdmImageInfo#getMimeType()}.

     */

    @Test

    public void testGetMimeType() {

        Assert.assertEquals(MimeType.JPEG.getMimeType(), getJpegInstance().getMimeType());

        Assert.assertEquals(MimeType.TIFF.getMimeType(), getTifInstance().getMimeType());

        try {

            Assert.assertEquals(MimeType.PNG.getMimeType(), getRemotePngBaseInfo().getMimeType());

        } catch (IOException e){

            if(e.getMessage().equals(OFFLINE)){

                logger.warn("test part skipped, since server is not available.");

            }

        }

    }

    @Test

    public void testGetLength(){

        Assert.assertEquals(55872, getJpegInstance().getLength());

        Assert.assertEquals(202926, getTifInstance().getLength());

        try {

            Assert.assertEquals(9143, getRemotePngBaseInfo().getLength());

        } catch (IOException e){

            if(e.getMessage().equals(OFFLINE)){

                logger.warn("test part skipped, since server is not available.");

            }

        }

    }

    @Test

    public void testGetSuffix(){

        Assert.assertEquals("jpg", getJpegInstance().getSuffix());

        Assert.assertEquals("tif", getTifInstance().getSuffix());

        try {

            Assert.assertEquals("png", getRemotePngBaseInfo().getSuffix());

        } catch (IOException e){

            if(e.getMessage().equals(OFFLINE)){

                logger.warn("test part skipped, since server is not available.");

            }

        }

    }

    @Test

    public void testReadMetaDataJpeg() throws IOException, HttpException{

        CdmImageInfo instance = new MediaMetadataFileReader(jpegUri).readMetaData().getCdmImageInfo();

        Map<String, String> metaData = instance.getMetaData();

        Assert.assertEquals(52, metaData.size());

        Assert.assertEquals("My taxon", metaData.get("Taxon"));

        Assert.assertEquals("on the road", metaData.get("Locality"));

        Assert.assertEquals("15.02.1955", metaData.get("Date"));

        Assert.assertEquals("Any person", metaData.get("Photographer"));

        Assert.assertEquals("My Keyword; Second Keyword", metaData.get("Keywords"));

    }

    @Test

    public void testReadMetaDataTif() throws IOException, HttpException{

        CdmImageInfo instance = new MediaMetadataFileReader(tiffUri).readBaseInfo().readMetaData().getCdmImageInfo();

        Map<String, String> metaData = instance.getMetaData();

        Assert.assertEquals(15, metaData.size());

    }

    @Test

    public void testReadMetaDataRemotePng() throws HttpException {

        try {

            CdmImageInfo instance = new MediaMetadataFileReader(remotePngUri).readMetaData().getCdmImageInfo();

            Map<String, String> metaData = instance.getMetaData();

            Assert.assertEquals(1, metaData.size());

        } catch (IOException e){

            if(e.getMessage().equals(OFFLINE)){

                logger.warn("test testReadMetaDataRemotePng() skipped, since server is not available.");

            }

        }

    }

}