Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

* 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 2

* 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, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

* MA  02110-1301, USA.

*

*/

package org.gvsig.raster.wmts.ogc.impl.base;

import java.io.BufferedOutputStream;

import java.io.ByteArrayInputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.IOException;

import java.net.HttpURLConnection;

import java.net.MalformedURLException;

import java.net.URL;

import java.nio.ByteBuffer;

import java.nio.channels.FileChannel;

import java.security.KeyManagementException;

import java.security.NoSuchAlgorithmException;

import java.util.ArrayList;

import java.util.Hashtable;

import java.util.List;

import java.util.StringTokenizer;

import java.util.prefs.Preferences;

import javax.net.ssl.HttpsURLConnection;

import javax.net.ssl.SSLContext;

import javax.net.ssl.TrustManager;

import javax.net.ssl.X509TrustManager;

import org.gvsig.compat.CompatLocator;

import org.gvsig.compat.net.Downloader;

import org.gvsig.compat.net.ICancellable;

import org.gvsig.raster.wmts.ogc.WMTSStatus;

import org.gvsig.raster.wmts.ogc.exception.DownloadException;

import org.gvsig.raster.wmts.ogc.exception.ServerErrorException;

import org.gvsig.raster.wmts.ogc.exception.WMTSException;

import org.gvsig.raster.wmts.ogc.impl.Tags;

import org.gvsig.raster.wmts.ogc.impl.Utilities;

import org.gvsig.raster.wmts.ogc.impl.request.WMTSGetCapabilitiesRequest;

import org.gvsig.raster.wmts.ogc.impl.request.WMTSGetFeatureInfoRequest;

import org.gvsig.raster.wmts.ogc.impl.request.WMTSGetTileRequest;

import org.gvsig.raster.wmts.ogc.struct.WMTSLayer;

import org.gvsig.raster.wmts.ogc.struct.WMTSOperationsMetadata;

import org.gvsig.raster.wmts.ogc.struct.WMTSStyle;

import org.kxml2.io.KXmlParser;

import org.xmlpull.v1.XmlPullParserException;

/**

 * <p> Abstract class that represents handlers to comunicate via WMS protocol.</p>

 * 

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public abstract class WMTSProtocolHandler {

        protected static final Downloader downloader = CompatLocator.getDownloader();

        /**

         * Encoding used to parse different xml documents.

         */

        protected String                 encoding                     = "UTF-8";

        private static int               count                        = 0;

        final String                     tempDirectoryPath            = System.getProperty("java.io.tmpdir")+"/tmp-andami";

        protected boolean                forceChangeAxisOrder         = false;

    protected String                 name;

    protected String                 version;

    protected String                 host;

    protected String                 port;  

    private WMTSServerDescription    serverDescription            = null;

    protected abstract WMTSGetFeatureInfoRequest createGetFeatureInfoRequest(WMTSStatusImpl status, int x, int y);

    protected abstract WMTSGetTileRequest createGetTileRequest(WMTSStatusImpl status);

    protected abstract WMTSGetCapabilitiesRequest createGetCapabilitiesRequest();

    /**

     * parses the data retrieved by the Capabilities XML document

     */

    public abstract boolean parseCapabilities(File f);

        public WMTSServerDescription getServerDescription() {

                if(serverDescription == null) {

                        serverDescription = new WMTSServerDescription(getVersion());

                }

                return this.serverDescription;

        }

    /**

     * @return Returns the host.

     */

    public String getHost() {

        return host;

    }

    /**

     * @param host The host to set.

     */

    public void setHost(String host) {

        this.host = host;

    }

    /**

     * @return Returns the name.

     */

    public String getName() {

        return name;

    }

    /**

     * @param name The name to set.

     */

    public void setName(String name) {

        this.name = name;

    }

    /**

     * @return Returns the port.

     */

    public String getPort() {

        return port;

    }

    /**

     * @param port The port to set.

     */

    public void setPort(String port) {

        this.port = port;

    }

    /**

     * @return Returns the version.

     */

    public String getVersion() {

        return version;

    }

    /**

     * @param version The version to set.

     */

    public void setVersion(String version) {

        this.version = version;

    }

    /**

     * Just for not repeat code. Gets the correct separator according 

     * to the server URL

     * @param h

     * @return

     */

    public String getSymbol(String h) {

        String symbol;

        if (h.indexOf("?")==-1) 

            symbol = "?";

        else if (h.indexOf("?")!=h.length()-1)

            symbol = "&";

        else

            symbol = "";

        return symbol;

    }  

    /**

     * Copy the file in a byte array

     * @param file

     * The file to copy

     * @return

     * An array of bytes

     * @throws IOException

     */

    protected byte[] fileToBytes(File file) throws IOException {

        FileInputStream fis = null;

        byte[] bytes = null;

        try{

            fis = new FileInputStream(file);

            //long length = file.length(); 

            bytes = new byte[(int)file.length()];

            int offset = 0;

            int numRead = 0; 

            while (offset < bytes.length && 

                    (numRead = fis.read(bytes, offset, bytes.length-offset)) >= 0) { 

                offset += numRead; 

            }

        } catch (IOException e) {

            throw e;

        } finally {

            if (fis != null) {

                fis.close();

            }

        }         

        return bytes;

    }

    /**

         * Sets longitude first in the axis order read from the capabilities file

         * @param force

         */

        public void setForceChangeAxisOrder(boolean force) {

                this.forceChangeAxisOrder = force;

        }

    //**************************************************************

    //Esto es temporal hasta que est? la cach?

        private Hashtable<URL, String>                downloadedFiles;

    /**

         * Returns the content of a URL as a file from the file system.<br>

         * <p>

         * If the URL has been already downloaded in this session and notified

         * to the system using the static <b>Utilities.addDownloadedURL(URL)</b>

         * method, it can be restored faster from the file system avoiding to

         * download it again.

         * </p>

         * @param url

         * @return File containing this URL's content or null if no file was found.

         */

        private File getPreviousDownloaded(Object object) {

                File f = null;

                if (downloadedFiles != null && downloadedFiles.containsKey(object)) {

                        String filePath = (String) downloadedFiles.get(object);

                        f = new File(filePath);

                        if (!f.exists())

                                return null;

                }

                return f;

        }

        /**

         * Adds an URL to the table of downloaded files for further uses. If the URL

         * already exists in the table its filePath value is updated to the new one and

         * the old file itself is removed from the file system.

         *

         * @param url

         * @param filePath

         */

        void addDownloadedURL(URL url, String filePath) {

                if (downloadedFiles == null)

                        downloadedFiles = new Hashtable<URL, String>();

                downloadedFiles.put(url, filePath);

        }

        //Fin del c?digo temporal hasta que est? la cach?

        //**************************************************************

    public synchronized File getTile(WMTSStatusImpl status, ICancellable cancel, File file) throws ServerErrorException, WMTSException {

            try {

                        WMTSGetTileRequest request = createGetTileRequest(status);

                        request.sendRequest(cancel, file);

                        try {

                                checkFileError(file);

                        } catch(WMTSException e) {

                                file.delete();

                                throw new WMTSException("This tile is not available:" + file.getAbsoluteFile().toString(), e);

                        } catch(IOException e) {

                                file.delete();

                                throw new WMTSException("This tile is not available:" + file.getAbsoluteFile().toString(), e);

                        }

                        return file;

                } catch(IOException e) {

            throw new WMTSException(e);

                }

    }

    public synchronized File getTile(WMTSStatus status, ICancellable cancel) throws ServerErrorException, WMTSException {

            try {

                        WMTSGetTileRequest request = createGetTileRequest((WMTSStatusImpl)status);

                        File f = request.sendRequest(cancel);

                        try {

                                checkFileError(f);

                        } catch(WMTSException e) {

                                downloader.removeURL(request);

                    throw new ServerErrorException();

                        }

                        return f;

                } catch(IOException e) {

                        e.printStackTrace();

            throw new ServerErrorException();

                }

    }

    public synchronized File getTile(String url, ICancellable cancel, File file) throws ServerErrorException, WMTSException {

            try {

                        downloadFile(new URL(url), cancel, file);

                        try {

                                checkFileError(file);

                        } catch(WMTSException e) {

                                file.delete();

                                throw new WMTSException("This tile is not available:" + file.getAbsoluteFile().toString(), e);

                        } catch(IOException e) {

                                file.delete();

                                throw new WMTSException("This tile is not available:" + file.getAbsoluteFile().toString(), e);

                        }

                        return file;

                } catch(IOException e) {

            throw new WMTSException(e);

                } catch (DownloadException e1) {

                        throw new WMTSException(e1);

                }

    }

    /**

     * Checks if the file downloaded is correct or doesn't

     * @param f

     * @throws WMTSException

     * @throws IOException

     */

    private void checkFileError(File f) throws WMTSException, IOException {

                if (f == null)

                    return;

            if (Utilities.isTextFile(f)) {

            byte[] data = fileToBytes(f);

                String exceptionMessage = parseException(data);

            if (exceptionMessage == null) {

                     String error = new String(data);

                    int pos = error.indexOf("<?xml");

                    if (pos!= -1) {

                            String xml = error.substring(pos,error.length());

                            exceptionMessage = parseException(xml.getBytes());

                    }

                if (exceptionMessage == null)

                        exceptionMessage = new String(data);

            }

            throw new WMTSException(exceptionMessage);

        }

    }

    public synchronized URL getTileURL(WMTSStatusImpl status) throws MalformedURLException {

            String onlineResource = getBaseURL(Tags.GETTILE);

                StringBuffer req = new StringBuffer();

                req.append(onlineResource)

                .append("REQUEST=GetTile&SERVICE=WMTS&VERSION=").append(getVersion()).append("&")

                .append("Layer=" + status.getLayer())

        .append("&Style=" + status.getStyle())

        .append("&Format=" + status.getFormat())

        .append("&TileMatrixSet=" + status.getTileMatrixSet())

        .append("&TileMatrix=" + status.getTileMatrix())

        .append("&TileRow=" + status. getTileRow())

        .append("&TileCol=" + status.getTileCol());

                return new URL(req.toString());

    }

    /**

     * Gets the URL base for a operation (GetCapabilities, GetTile, ...)

     * @param operation

     * @return the base URL for the GET protocol or the host passed by the user 

     * if it does not exists. 

     */

    public String getBaseURL(String operation) {

            String onlineResource = null;

            WMTSServerDescription svDescription = getServerDescription();

            if(svDescription != null) {

                    WMTSOperationsMetadata opMetadata = svDescription.getOperationsMetadata();

                    if(opMetadata != null)

                            onlineResource = opMetadata.getOnlineResource(operation);

            }

            if(onlineResource == null)

                    onlineResource = getHost();

                String symbol = getSymbol(onlineResource);

                onlineResource = onlineResource + symbol;

                return onlineResource;

    }

    /**

     * Gets the URL base for a operation (GetCapabilities, GetTile, ...) and 

     * a protocol GET or POST

     * @param operation

     * @return the base URL for this protocol or null if it does not exists. 

     */

    public String getBaseURL(String operation, int protocol) {

            String onlineResource = null;

            WMTSServerDescription svDescription = getServerDescription();

            if(svDescription != null) {

                    WMTSOperationsMetadata opMetadata = svDescription.getOperationsMetadata();

                    if(opMetadata != null) {

                            onlineResource = opMetadata.getOnlineResource(operation, protocol);

                            if(onlineResource != null) {

                                    String symbol = getSymbol(onlineResource);

                                    return onlineResource + symbol;

                            }

                    }

            }

                return null;

    }

    /**

     * Gets a file name to download. I

     * @param url

     * @return

     */

    private File getFile() {

            count ++;

                int index = name.lastIndexOf(".");

                if (index > 0){

                        return new File(tempDirectoryPath + "/" + name.substring(0,index) + System.currentTimeMillis() + count + 

                                name.substring(index, name.length()));

                }

                return new File(tempDirectoryPath + "/" + name + System.currentTimeMillis() + count);

    }

    public synchronized File downloadFile(URL url, ICancellable cancel, File forceFile) throws DownloadException {

            if(forceFile == null) {

                    File f = null;

                    if((f = getPreviousDownloaded(url)) != null)

                            return f;

            }

            Preferences prefs = Preferences.userRoot().node( "gvsig.downloader" );

            int IO_BUFFER_SIZE = 8 * 1024;

                int timeout = prefs.getInt("timeout", 60000);

                File dstFile = forceFile;

                if(dstFile == null)

                        dstFile = getFile();

                DataOutputStream dos;

                try {

                        DataInputStream is;

                        //OutputStreamWriter os = null;

                        HttpURLConnection connection = null;

                        if (url.getProtocol().equals("https")) {

                                disableHttsValidation();

                        }

                        connection = (HttpURLConnection)url.openConnection();

                        connection.setConnectTimeout(timeout);

                        is = new DataInputStream(url.openStream());

                        dos = new DataOutputStream( new BufferedOutputStream(new FileOutputStream(dstFile)));

                        byte[] buffer = new byte[IO_BUFFER_SIZE];

                        int read;

                        while ((read = is.read(buffer)) != -1) {

                                dos.write(buffer, 0, read);

                        }

                        /*if(os != null) {

                                os.close();

                        }*/

                        dos.close();

                        is.close();

                        is = null;

                        dos = null;

                        if (cancel != null && cancel.isCanceled()) {

                                dstFile.delete();

                                dstFile = null;

                                return null;

                        }

                } catch (Exception e) {

                        throw new DownloadException(e);

                }

                addDownloadedURL(url, dstFile.getAbsolutePath());

                return dstFile;

    }

    /**

         * This method disables the Https certificate validation.

         * @throws KeyManagementException

         * @throws NoSuchAlgorithmException

         */

        private void disableHttsValidation() throws KeyManagementException, NoSuchAlgorithmException{

                // Create a trust manager that does not validate certificate chains

                TrustManager[] trustAllCerts = new TrustManager[] {

                                new X509TrustManager() {

                                        public java.security.cert.X509Certificate[] getAcceptedIssuers() {

                                                return null;

                                        }

                                        public void checkClientTrusted(

                                                        java.security.cert.X509Certificate[] certs, String authType) {

                                        }

                                        public void checkServerTrusted(

                                                        java.security.cert.X509Certificate[] certs, String authType) {

                                        }

                                }

                };

                // Install the all-trusting trust manager

                SSLContext sc = SSLContext.getInstance("SSL");

                sc.init(null, trustAllCerts, new java.security.SecureRandom());

                HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());

        }

        /**

     * @return string that represents the url for getting the wms legend

     * If the layer has the object layer-->style-->legendurl that url will be returned 

     * otherwise builds the getLegendGraphic according to the OGC WMS Specifications

     * 

     */

    /*private String buildGetLegendGraphicRequest(WMTSLayer layer, WMTSStyle style) {

            String onlineResource = style.getLegendURL().getHref();

                String symbol = getSymbol(onlineResource);

                String layerName = layer.getTitle();

                if(onlineResource == null || onlineResource.equals(""))

                        return null;

                StringBuffer req = new StringBuffer();

                req.append(onlineResource + symbol + "REQUEST=GetLegendGraphic&SERVICE=WMS&VERSION=").append(getVersion());

        req.append("&LAYER=" + layerName).append("&TRANSPARENT=TRUE").append("&FORMAT=image/png");

        String aux = req.toString().replaceAll(" ", "%20");

        System.out.println("GetLegendGraphic url:" + aux);

                return aux;

    }*/

        public File getLegendGraphic(WMTSLayer layer, WMTSStyle style, ICancellable cancel) 

                        throws ServerErrorException, WMTSException, DownloadException {

                URL request = null;

                try {

                        String requestStr = style.getLegendURL().getHref();

                        if(requestStr == null || requestStr.equals(""))

                                return null;

                        request = new URL(requestStr);

                        System.out.println(requestStr);

                        File f = downloadFile(request, cancel, null);

                        if (f== null)

                                return null;

                        if (Utilities.isTextFile(f)) {

                                FileInputStream fis = new FileInputStream(f);

                                FileChannel fc = fis.getChannel();

                                byte[] data = new byte[(int)fc.size()];

                                ByteBuffer bb = ByteBuffer.wrap(data);

                                fc.read(bb);

                                WMTSException wmsEx = null;

                                String exceptionMessage = parseException(data);

                                if (exceptionMessage == null) {

                                        String error = new String(data);

                                        int pos = error.indexOf("<?xml");

                                        if (pos!= -1) {

                                                String xml = error.substring(pos,error.length());

                                                exceptionMessage = parseException(xml.getBytes());

                                        }

                                        if (exceptionMessage == null)

                                                exceptionMessage = new String(data);

                                }

                                wmsEx = new WMTSException(exceptionMessage);

                                wmsEx.setWMTSMessage(new String(data));

                                Utilities.removeURL(request);

                                fis.close();

                                throw wmsEx;

                        }

                        return f;

                } catch(IOException e) {

                        e.printStackTrace();

                        throw new ServerErrorException();

                }

        }

        /**

         * <p>It will send a GetFeatureInfo request to the WMTS

     * Parsing the response and redirecting the info to the WMTS client</p>

     * TODO: return a stored file instead a String.

     */

    public String getFeatureInfo(WMTSStatusImpl status, int x, int y, ICancellable cancel) {

            StringBuffer output = new StringBuffer();

            String outputFormat = new String();

            String ServiceException = "ServiceExceptionReport";

            StringBuffer sb = new StringBuffer();

            sb.append("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>");

                try {

                        WMTSGetFeatureInfoRequest request = createGetFeatureInfoRequest(status, x, y);

                        URL url = request.getURL();

                    outputFormat = url.openConnection().getContentType();

                    File f = request.sendRequest(cancel);

                        if (f == null) {

                                return "";

                        }

                        FileReader fReader = new FileReader(f);

                        char[] buffer = new char[1024*256];

                        for (int i = fReader.read(buffer);i > 0;i = fReader.read(buffer)) {

                            String str = new String(buffer, 0, i);

                            output.append(str);

                    }

                        fReader.close();

                    if ( (outputFormat == null) || (outputFormat.indexOf("xml") != -1)

                                    ||output.toString().toLowerCase().startsWith("<?xml")

                                    ||(outputFormat.indexOf("gml") != -1)) {

                            KXmlParser kxmlParser = null;

                            kxmlParser = new KXmlParser();

                            //kxmlParser.setInput(new StringReader(output.toString()));

                            kxmlParser.setInput(new FileReader(f));

                            kxmlParser.nextTag();

                            if (kxmlParser.getName().compareTo(ServiceException) == 0) {

                                    sb.append("<INFO>").append(parseException( output.toString().getBytes())).append("</INFO>");

                                    return sb.toString();

                                } else if (kxmlParser.getName().compareToIgnoreCase("ERROR") == 0) {

                                        return output.toString();

                                } else {

                                        return output.toString();

                                }

                    } else {                  

                             return output.toString();

                    }

                } catch(XmlPullParserException parserEx) {

                    if (output.toString().toLowerCase().indexOf("xml") != -1) {

                            return output.toString().trim();

                    } else {

                               sb.append("<INFO>").append("Info format not supported").append("</INFO>");

                        return sb.toString();

                    }

            } catch(Exception e) {

                    e.printStackTrace();

                    sb.append("<INFO>").append("Info format not supported").append("</INFO>");

                    return sb.toString();

            }

    }

    /**

         * <p>Builds a GetCapabilities request that is sent to the WMS

         * the response will be parse to extract the data needed by the

         * WMS client</p>

         * @param override, if true the previous downloaded data will be overridden

         */

    public void getCapabilities(WMTSServerDescription status, boolean override, ICancellable cancel) {

            try {

                    serverDescription = status;

                        WMTSGetCapabilitiesRequest request = createGetCapabilitiesRequest();

                        File f = request.sendRequest(cancel);                        

                        if (f == null)

                                return;

                        parseCapabilities(f);

            } catch(Exception e) {

                        e.printStackTrace();

                }

    }

    /**

     * Builds the GetCapabilitiesRequest according to the OGC WMS Specifications

     * without a VERSION, to get the highest version than a WMS supports.

     */

    public static String buildCapabilitiesSuitableVersionRequest(String _host, String _version) {

                int index = _host.indexOf('?');

                if (index > -1) {

                        String host = _host.substring(0, index + 1);

                        String query = _host.substring(index + 1, _host.length());

                        StringTokenizer tokens = new StringTokenizer(query, "&");

                        String newQuery = "", token;

                        // If there is a field or a value with spaces, (and then it's on different tokens) -> unify them

                        while (tokens.hasMoreTokens()) {

                                token = tokens.nextToken().trim();

                                if (token.toUpperCase().compareTo("REQUEST=GETCAPABILITIES") == 0)

                                        continue;

                                if (token.toUpperCase().compareTo("SERVICE=WMTS") == 0)

                                        continue;

                                if ((_version != null) && (_version.length() > 0)) {

                                    if (token.toUpperCase().compareTo("VERSION=" + _version) == 0)

                                            continue;

                                }

                                if (token.toUpperCase().compareTo("EXCEPTIONS=XML") == 0)

                                        continue;

                                newQuery += token + "&";

                        }

                _host = host + newQuery;

                }

                else {

                        _host += "?";

                }

            if ((_version != null) && (_version.compareTo("") != 0))

                    _host += "REQUEST=GetCapabilities&SERVICE=WMTS&VERSION=" + _version;

            else

                    _host += "REQUEST=GetCapabilities&SERVICE=WMTS";

            return _host;

    }

        protected String parseException(byte[] data) throws IOException {

        List<String> errors = new ArrayList<String>();

        KXmlParser kxmlParser = new KXmlParser();

        try

        {

            kxmlParser.setInput(new ByteArrayInputStream(data), encoding);

            kxmlParser.nextTag();

            int tag;

            if ( kxmlParser.getEventType() != KXmlParser.END_DOCUMENT )

            {

                kxmlParser.require(KXmlParser.START_TAG, null, Tags.EXCEPTION_ROOT);

                tag = kxmlParser.nextTag();

                 while(tag != KXmlParser.END_DOCUMENT)

                 {

                     switch(tag)

                     {

                        case KXmlParser.START_TAG:

                            if (kxmlParser.getName().compareTo(Tags.SERVICE_EXCEPTION)==0){

                                String errorCode = kxmlParser.getAttributeValue("", Tags.CODE);

                                errorCode = (errorCode != null) ? "["+errorCode+"] " : "";

                                String errorMessage = kxmlParser.nextText();

                                errors.add(errorCode + errorMessage);

                            }

                            break;

                        case KXmlParser.END_TAG:

                            break;

                     }

                     tag = kxmlParser.nextTag();

                 }

                 //kxmlParser.require(KXmlParser.END_DOCUMENT, null, null);

            }

        }

        catch(XmlPullParserException parser_ex){

            throw new IOException(parser_ex.getMessage());

        }

        String message = errors.size() > 0? "" : null;

        for (int i = 0; i < errors.size(); i++) {

            message += (String) errors.get(i)+"\n";

        }

        return message;

    }

 }