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.wcs.io;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.BufferedOutputStream;

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.net.ConnectException;

import java.net.HttpURLConnection;

import java.net.URL;

import java.security.KeyManagementException;

import java.security.NoSuchAlgorithmException;

import java.util.ArrayList;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Set;

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.net.ICancellable;

import org.gvsig.fmap.dal.coverage.exception.RemoteServiceException;

import org.gvsig.remoteclient.exceptions.ServerErrorException;

import org.gvsig.remoteclient.exceptions.WCSException;

import org.gvsig.remoteclient.utils.BoundaryBox;

import org.gvsig.remoteclient.wcs.WCSClient;

import org.gvsig.remoteclient.wcs.WCSCoverage;

import org.gvsig.remoteclient.wcs.WCSStatus;

import org.gvsig.remoteclient.wcs.WCSCoverage.AxisDescription;

import org.gvsig.remoteclient.wcs.WCSCoverage.RectifiedGrid;

/**

 * Connector between a WCS data provider and a WCSClient. 

 *

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

 */

public class WCSConnector  {

        private WCSClient                         client;

        private Hashtable<String, WCSLayerNode>   coverages;

    private WCSLayerNode[]                    layerList;

    public WCSConnector(URL url) throws ConnectException, IOException {

            client = new WCSClient(url.toString());

    }

        /**

         * Returns the string "WCSDriver", which is the driver's name.

         * @return String

         */

        public String getName() { 

                return "WCSDriver"; 

        }

        /**

         * Sets the server that we want to connect to.

         *

         * @param host

         * @throws IOException

         */

        public void setHost(String host) throws IOException{

                client = new WCSClient(host);

        }

        /**

         * Returns a human-readable string containing the server's name.

         *

         * @return String

         */

        public String getLabel() {

                return client.getServiceTitle();

        }

        /**

         * Returns a string containing the server's WCS version number.

         *

         * @return String

         */

        public String getVersion(){

                return client.getVersion();

        }

        /**

         * <p>

         * Returns name and description of the server. It is supposed to be used

         * as the source of the abstract field in your application's interface.

         * </p>

         * <p>

         * Devuelve nombre y descripci?n (abstract) del servidor.

         * </p>

         * @return String

         */

        public String getDescription(){

                return client.getDescription();

        }

        /**

         * Returns the layer descriptor for a given coverage name.

         * @param layerName

         * @return WCSLayer

         */

        public WCSLayerNode getLayer(String layerName) {

                getLayerList();

                return (WCSLayerNode) getCoverages().get(layerName);

        }

        private Hashtable<String, WCSLayerNode> getCoverages() {

                if(coverages == null || coverages.isEmpty()) {

                        getLayerList();

                }

                return coverages;

        }

        /**

         * Returns an array of WCSLayer's with the descriptors of all coverages

         * @return WCSLayer[]

         */

        public WCSLayerNode[] getLayerList() {

                if (coverages == null || coverages.isEmpty()) {

                        // the WCSLayer collection will be built

                        coverages = new Hashtable<String, WCSLayerNode>();

                        Hashtable wcsCoverages  = client.getCoverageList();

                        int sz = wcsCoverages.size();

                        // Create an array with the WCSCoverages

                        WCSCoverage[] coverageList = new WCSCoverage[sz];

                        Iterator it = wcsCoverages.keySet().iterator();

                        int i = 0;

                        while (it.hasNext()) {

                                coverageList[i] = (WCSCoverage) wcsCoverages.get(it.next());

                                i++;

                        }

                        // Create a WCSLayer array from the previous WCSCoverage array

                        layerList = new WCSLayerNode[sz];

                        for (int j = 0; j < layerList.length; j++) {

                                WCSLayerNode lyr = new WCSLayerNode();

                                WCSCoverage cov = coverageList[j];

                                // name

                                lyr.setName(cov.getName());

                                // title

                                lyr.setTitle(cov.getTitle());

                                // description

                                lyr.setDescription(cov.getAbstract());

                                // srs

                                lyr.addAllSrs(cov.getAllSrs());

                                // native srs

                                lyr.setNativeSRS(cov.getNativeSRS());

                                // extents

                                Set k = cov.getBBoxes().keySet();

                                if (!k.isEmpty()) {

                                        it = k.iterator();

                                        while (it.hasNext()) {

                                                String srs = (String) it.next();

                                                BoundaryBox bBox = cov.getBbox(srs);

                                                Rectangle2D r = new Rectangle2D.Double(

                                                                bBox.getXmin(),

                                                                bBox.getYmin(),

                                                                bBox.getXmax() - bBox.getXmin(),

                                                                bBox.getYmax() - bBox.getYmin()

                                                );

                                                lyr.addExtent(srs, r);

                                        }

                                }

                                // formats

                                lyr.setFormats(cov.getFormats());

                                // time positions

                                lyr.setTimePositions(cov.getTimePositions());

                                RectifiedGrid rf = cov.getRectifiedGrid();

                                int w = rf.getHighGridEnvelopLimits()[0][0] - rf.getLowGridEnvelopLimits()[0][0];

                                int h = rf.getHighGridEnvelopLimits()[0][1] - rf.getLowGridEnvelopLimits()[0][1]; 

                                lyr.setWidth(w);

                                lyr.setHeight(h);

                                // max res

                                lyr.setMaxRes(new Point2D.Double(cov.getResX(), cov.getResY()));

                                // interpolations

                                lyr.setInterpolationMethods(cov.getInterpolationMethods());

                                // parameters

                                k = cov.axisPool.keySet();

                                if (!k.isEmpty()) {

                                        it = k.iterator();

                                        while (it.hasNext()) {

                                                AxisDescription ad = (AxisDescription) cov.axisPool.get(it.next());

                                                FMapWCSParameter p = new FMapWCSParameter();

                                                p.setName(ad.getName());

                                                p.setLabel(ad.getLabel());

                                                p.setType(ad.getInterval() == null ? FMapWCSParameter.VALUE_LIST : FMapWCSParameter.INTERVAL);

                                                if (p.getType() == FMapWCSParameter.VALUE_LIST) {

                                                        p.setValueList(ad.getSingleValues());

                                                } /*else {

                                                        p.setInterval(ad.getInterval());

                                                }*/

                                                lyr.addParameter(p);

                                        }

                                }

                                layerList[j] = lyr;

                                coverages.put(lyr.getName(), lyr);

                        }

                }

                return layerList;

        }

        /**

         * Establishes the connection to the WCS server. Connecting to a WCS is

         * an abstraction.<br>

         * <p>

         * Actually, it sends a GetCapabilities and a general DescribeCoverage

         * request (not a coverage-specific DescribeCoverage request) to read the

         * necessary data for building further GetCoverage requests.

         * </p>

         * @param override

         * @throws IOException.

         */

        public boolean connect(boolean override, ICancellable cancel)

                        throws IOException {

                coverages = null;

                setHost(client.getHost());

                return client.connect(override, cancel);

        }

        /**

         * No close operation is needed since WCS service it is a non-session based

         * protocol. So, this does nothing and you can omit it.<br>

         */

        public void close() {

//                connected = false;

        }

        /**

         * Returns the label of an specific coverage given by the coverage name

         * @param coverage name (string)

         * @return string

         */

        public String getLabel(String coverageName) {

                return client.getLabel(coverageName);

        }

        /**

         * Returns the coverage's MAX extent from the server.

         * @return Rectangle2D

         * @throws IOException

         */

        public Rectangle2D getFullExtent(String coverageName, String srs)

                        throws IOException {

                return client.getExtent(coverageName, srs);

        }

        /**

         * Returns the max resolution of a specific coverage given by the coverage's name.

         * @param coverage name (string)

         * @return double

         */

        public Point2D getMaxResolution(String coverageName) {

                if (getCoverages().containsKey(coverageName)) {

                        return ((WCSLayerNode) getCoverages().get(coverageName)).getMaxRes();

                }

                return null;

        }

        /**

         * Gets the maximum width in pixels of this coverage

         * @param coverageName

         * @return

         */

        public int getWidth(String coverageName) {

                if (getCoverages().containsKey(coverageName)) {

                        return ((WCSLayerNode) getCoverages().get(coverageName)).getWidth();

                }

                return 0;

        }

        /**

         * Gets the maximum height in pixels of this coverage

         * @param coverageName

         * @return

         */

        public int getHeight(String coverageName) {

                if (getCoverages().containsKey(coverageName)) {

                        return ((WCSLayerNode) getCoverages().get(coverageName)).getHeight();

                }

                return 0;

        }

        /**

         * Returns an ArrayList containing a set of Strings with the coverage's SRSs.

         * @param coverage name (string)

         * @return ArrayList

         */

        public ArrayList getSRSs(String coverageName) {

                if (getCoverages().containsKey(coverageName)) {

                        return ((WCSLayerNode) getCoverages().get(coverageName)).getSRSs();

                }

                return null;

        }

        /**

         * Returns a String containing a description of an specific coverage.

         * @param coverage name (string)

         * @return string

         */

        public String getCoverageDescription(String coverageName) {

                if (getCoverages().containsKey(coverageName)) {

                        return ((WCSLayerNode) getCoverages().get(coverageName)).getDescription();

                }

                return null;

        }

        /**

         * Returns an ArrayList containing strings for the time positions of an

         * specific coverage given by the coverage's name.

         * @param coverage name (string)

         * @return ArrayList

         */

        public ArrayList getTimes(String coverageName) {

                if (getCoverages().containsKey(coverageName)) {

                        return ((WCSLayerNode) getCoverages().get(coverageName)).getTimePositions();

                }

                return null;

        }

        /**

         * Sends a GetCoverage request to the client.

         * @param status

         * @return

         * @throws WCSException

         */

        public File getCoverage(WCSStatus status, ICancellable cancel) throws RemoteServiceException {

                try {

                        return client.getCoverage(status, cancel);

                } catch (ServerErrorException e) {

                        throw new RemoteServiceException(getName(), e);

                } catch (org.gvsig.remoteclient.exceptions.WCSException e) {

                        throw new RemoteServiceException(e.getMessage(), e);

                }

        }

        /**

         * Sends a GetCoverage request to the client.

         * @param status

         * @return

         * @throws WCSException

         */

        public void getCoverageURL(WCSStatus status, ICancellable cancel, File file) throws RemoteServiceException {

                try {

                        URL url = client.getCoverageURL(status, cancel);

                        downloadFile(url, file, cancel);

                        String exceptionMessage = client.getExceptionMessage(file);

                        if(exceptionMessage != null)

                                throw new RemoteServiceException(exceptionMessage);

                } catch(IOException e) {

                        throw new RemoteServiceException("WMS: error downloading the file. File:" + file.getAbsolutePath() + "...." + e.getMessage());

                } catch (ServerErrorException e) {

                        throw new RemoteServiceException("WMS Unexpected server error."+e.getMessage());

                }  catch (org.gvsig.remoteclient.exceptions.WMSException e) {

                        throw new RemoteServiceException(e.getMessage());

                }

        }

        public void downloadFile(URL url, File dstFile, ICancellable cancel) throws IOException {

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

                // by default 1 minute (60000 milliseconds.

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

                DataOutputStream dos;

                DataInputStream is;

                OutputStreamWriter os = null;

                HttpURLConnection connection = null;

                //If the used protocol is HTTPS

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

                        try {

                                disableHttsValidation();

                        } catch (KeyManagementException e) {

                                e.printStackTrace();

                        } catch (NoSuchAlgorithmException e) {

                                e.printStackTrace();

                        }

                }

                connection = (HttpURLConnection)url.openConnection();

                connection.setConnectTimeout(timeout);

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

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

                byte[] buffer = new byte[1024 * 4];

                long readed = 0;

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

                        dos.write(buffer, 0, i);

                        readed += i;

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

                                return;

                }

                if(os != null) {

                        os.close();

                }

                dos.close();

                is.close();

                is = null;

                dos = null;

        }

        /**

         * 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());

        }

}