Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

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

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

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

/*

 * AUTHORS (In addition to CIT):

 * 2010 {Prodevelop}   {Task}

 */

package org.gvsig.installer.lib.impl;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.net.URL;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import org.gvsig.installer.lib.api.DependenciesCalculator;

import org.gvsig.installer.lib.api.Dependency;

import org.gvsig.installer.lib.api.InstallerManager;

import org.gvsig.installer.lib.api.PackageInfo;

import org.gvsig.installer.lib.api.PackageInfoReader;

import org.gvsig.installer.lib.api.PackageInfoWriter;

import org.gvsig.installer.lib.api.Version;

import org.gvsig.installer.lib.api.creation.MakePackageService;

import org.gvsig.installer.lib.api.creation.MakePluginPackageService;

import org.gvsig.installer.lib.api.creation.MakePluginPackageServiceException;

import org.gvsig.installer.lib.api.execution.InstallPackageService;

import org.gvsig.installer.lib.api.execution.InstallPackageServiceException;

import org.gvsig.installer.lib.impl.creation.DefaultMakePackageService;

import org.gvsig.installer.lib.impl.info.InstallerInfoFileReader;

import org.gvsig.installer.lib.impl.info.InstallerInfoFileWriter;

import org.gvsig.installer.lib.spi.InstallerProviderManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.extensionpoint.ExtensionPoint;

import org.gvsig.tools.extensionpoint.ExtensionPointManager;

import org.gvsig.tools.service.AbstractManager;

import org.gvsig.tools.service.Service;

import org.gvsig.tools.service.ServiceException;

import org.gvsig.tools.service.spi.NotRegisteredException;

import org.gvsig.tools.service.spi.ParametersException;

/**

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera Llodr&aacute;</a>

 */

public class DefaultInstallerManager extends AbstractManager implements

                InstallerManager {

        private static final String INSTALLER_MANAGER_EXTENSION_POINT = "InstallerManagerExtensionPoint";

        private static final String INSTALLER_CREATION_SERVICE_NAME = "InstallerCreationService";

        private static final String INSTALLER_EXECUTION_SERVICE_NAME = "InstallerExecutionService";

        private ExtensionPointManager extensionPoints = ToolsLocator

                        .getExtensionPointManager();

        private String packageSetNameFormat = "gvSIG-desktop-{0}-{1}-{2}-{4}-{5}-{6}-{7}.gvspks";

        private String packageNameFormat = "gvSIG-desktop-{0}-{1}-{2}-{4}-{5}-{6}-{7}.gvspkg";

        private String packageIndexNameFormat = "gvSIG-desktop-{0}-{1}-{2}-{4}-{5}-{6}-{7}.gvspki";

        private URL BaseDownloadURL = null;

        private Version version = null;

        private Set<File> repositoriesPaths = null;

        private File defaultRepositoriesPath = null;

        public DefaultInstallerManager() {

                super(new DefaultInstallerProviderManager());

                repositoriesPaths = new HashSet<File>();

        }

        public String getPackageSetNameFormat() {

                return packageSetNameFormat;

        }

        public void setPackageSetNameFormat(String packageSetNameFormat) {

                this.packageSetNameFormat = packageSetNameFormat;

        }

        public String getPackageNameFormat() {

                return packageNameFormat;

        }

        public void setPackageNameFormat(String packageNameFormat) {

                this.packageNameFormat = packageNameFormat;

        }

        public String getPackageIndexNameFormat() {

                return packageIndexNameFormat;

        }

        public void setPackageIndexNameFormat(String packageIndexNameFormat) {

                this.packageIndexNameFormat = packageIndexNameFormat;

        }

        public MakePluginPackageService getMakePluginPackageService()

                        throws MakePluginPackageServiceException {

                ExtensionPoint ep = extensionPoints

                                .add(INSTALLER_MANAGER_EXTENSION_POINT);

                try {

                        Object[] args = new Object[] { this };

                        return (MakePluginPackageService) ep.create(

                                        INSTALLER_CREATION_SERVICE_NAME, args);

                } catch (Exception e) {

                        throw new MakePluginPackageServiceException(

                                        "Exception creating the installer service to create installers",

                                        e);

                }

        }

        public class InstallerCreationException extends

                        InstallPackageServiceException {

                private static final long serialVersionUID = 759329820705535873L;

                private static final String message = "Error creating the installer service to install plugins";

                private static final String KEY = "_Error_creating_the_installer_service_to_install_plugins";

                public InstallerCreationException(Exception e) {

                        super(message, e, KEY, serialVersionUID);

                }

        }

        public InstallPackageService getInstallPackageService()

                        throws InstallPackageServiceException {

                ExtensionPoint ep = extensionPoints

                                .add(INSTALLER_MANAGER_EXTENSION_POINT);

                try {

                        Object[] args = new Object[1];

                        args[0] = this;

                        return (InstallPackageService) ep.create(

                                        INSTALLER_EXECUTION_SERVICE_NAME, args);

                } catch (Exception e) {

                        throw new InstallerCreationException(e);

                }

        }

        public void registerMakePluginPackageService(

                        Class<? extends MakePluginPackageService> clazz) {

                ExtensionPoint extensionPoint = extensionPoints.add(

                                INSTALLER_MANAGER_EXTENSION_POINT, "");

                extensionPoint.append(INSTALLER_CREATION_SERVICE_NAME, "", clazz);

        }

        public void registerInstallPackageService(

                        Class<? extends InstallPackageService> clazz) {

                ExtensionPoint extensionPoint = extensionPoints.add(

                                INSTALLER_MANAGER_EXTENSION_POINT, "");

                extensionPoint.append(INSTALLER_EXECUTION_SERVICE_NAME, "", clazz);

        }

        public Service getService(DynObject parameters) throws ServiceException {

                return null;

        }

        public String getPackageSetFileName(PackageInfo info) {

                Object[] parameters = getPackageNameFormatParameters(info);

                return MessageFormat.format(getPackageSetNameFormat(), parameters);

        }

        public String getPackageFileName(PackageInfo info) {

                Object[] parameters = getPackageNameFormatParameters(info);

                return MessageFormat.format(getPackageNameFormat(), parameters);

        }

        public String getPackageIndexFileName(PackageInfo info) {

                Object[] parameters = getPackageNameFormatParameters(info);

                return MessageFormat.format(getPackageIndexNameFormat(), parameters);

        }

        private Object[] getPackageNameFormatParameters(PackageInfo info) {

                Object[] parameters = new Object[8];

                parameters[PACKAGE_FILE_NAME_FIELDS.GVSIG_VERSION] = info

                                .getGvSIGVersion();

                parameters[PACKAGE_FILE_NAME_FIELDS.NAME] = info.getCode();

                parameters[PACKAGE_FILE_NAME_FIELDS.VERSION] = info.getVersion();

                parameters[PACKAGE_FILE_NAME_FIELDS.BUILD] = info.getBuild();

                parameters[PACKAGE_FILE_NAME_FIELDS.STATE] = info.getState();

                parameters[PACKAGE_FILE_NAME_FIELDS.OS] = info.getOperatingSystem();

                parameters[PACKAGE_FILE_NAME_FIELDS.ARCH] = info.getArchitecture();

                parameters[PACKAGE_FILE_NAME_FIELDS.JVM] = info.getJavaVM();

                return parameters;

        }

        public PackageInfo[] getInstalledPackages(File pluginsDirectory)

                        throws MakePluginPackageServiceException {

                MakePluginPackageService service = getMakePluginPackageService();

                return service.getInstalledPackages();

        }

        public PackageInfo[] getInstalledPackages()

                        throws MakePluginPackageServiceException {

                MakePluginPackageService service = getMakePluginPackageService();

                return service.getInstalledPackages();

        }

        public String getDefaultPackageFileExtension() {

                return "gvspkg";

        }

        public String getDefaultPackageSetFileExtension() {

                return "gvspks";

        }

        public String getDefaultIndexSetFileExtension() {

                return "gvspki";

        }

        public String getOperatingSystem() {

                String osname = System.getProperty("os.name");

                if (osname.toLowerCase().startsWith("linux")) {

                        return InstallerManager.OS.LINUX;

                }

                if (osname.toLowerCase().startsWith("window")) {

                        return InstallerManager.OS.WINDOWS;

                }

                return osname;

        }

        public String getArchitecture() {

                String osarch = System.getProperty("os.arch");

                if (osarch.toLowerCase().startsWith("i386")) {

                        return InstallerManager.ARCH.X86;

                }

                if (osarch.toLowerCase().startsWith("x86")) {

                        return InstallerManager.ARCH.X86;

                }

                if (osarch.toLowerCase().startsWith("amd64")) {

                        return InstallerManager.ARCH.X86_64;

                }

                return osarch;

        }

        public Dependency createDependency(PackageInfo packageInfo) {

                return new DefaultDependency(packageInfo);

        }

        public Dependency createDependency() {

                return new DefaultDependency();

        }

        public DependenciesCalculator createDependenciesCalculator(

                        InstallPackageService installService) {

                return new DefaultDependenciesCalculator(installService);

        }

        public Version createVersion() {

                if( version == null ) {

                        return new DefaultVersion();

                }

                Version v = null;

                try {

                        v = (Version) version.clone();

                } catch (CloneNotSupportedException e) {

                        // Version clone can't trow exception

                }

                return v;

        }

        public PackageInfoReader getDefaultPackageInfoReader() {

                return new InstallerInfoFileReader();

        }

        public PackageInfoWriter getDefaultPackageInfoWriter() {

                return new InstallerInfoFileWriter();

        }

        public MakePackageService createMakePackage(File packageFolder,

                        PackageInfo packageInfo) {

                return new DefaultMakePackageService(this, packageFolder, packageInfo);

        }

        public PackageInfo createPackageInfo() {

                return new DefaultPackageInfo();

        }

        public PackageInfo createPackageInfo(InputStream stream) throws BaseException  {

                PackageInfo pkg = new DefaultPackageInfo();

                PackageInfoReader reader = this.getDefaultPackageInfoReader();

                reader.read(pkg, stream);

                return pkg;

        }

        public URL getDownloadBaseURL() {

                return this.BaseDownloadURL;

        }

        public String getVersion() {

                return this.version.toString();

        }

    public void setVersion(Version version) {

        try {

            this.version = (Version) version.clone();

        } catch (CloneNotSupportedException e) {

            // This should not happen

        }

    }

    public Version getVersionEx() {

        try {

            return (Version) this.version.clone();

        } catch (CloneNotSupportedException e) {

            // This should not happen

            return null;

        }

    }

        public void setDownloadBaseURL(URL url) {

                this.BaseDownloadURL = url;

        }

        public void setVersion(String version) {

                if( this.version == null ) {

                        this.version = new DefaultVersion();

                }

                this.version.parse(version);

        }

        public File getDefaultLocalAddonRepository() {

                return this.defaultRepositoriesPath;

        }

        public void setDefaultLocalAddonRepository(File defaultAddonsRepository) {

                this.defaultRepositoriesPath = defaultAddonsRepository;

                this.repositoriesPaths.add(defaultAddonsRepository);

        }

        public void addLocalAddonRepository(File path) {

                repositoriesPaths.add(path);

        }

        public List<File> getLocalAddonRepositories() {

                List<File> l = new ArrayList<File>();

                l.addAll(repositoriesPaths);

                return l;

        }

        public List<File> getAddonFolders() {

                List<File> addonFolders = new ArrayList<File>();

                // Para cada directorio en repositoriesPathsList

                List<File> localAddonRepositories = this.getLocalAddonRepositories();

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

                        File repoPath = localAddonRepositories.get(i);

                        if (repoPath.isDirectory() && repoPath.exists()) {

                                File[] folderRepoList = repoPath.listFiles();

                                // recorrer los directorios que haya dentro

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

                                        File addonFolder = folderRepoList[j];

                                        if (addonFolder.isDirectory()) {

                                                File pkginfofile = new File(addonFolder, "package.info");

                                                if (pkginfofile.exists()) {

                                                        addonFolders.add(addonFolder);

                                                }

                                        }

                                }

                        }

                }

                return addonFolders;

        }

        public File getAddonFolder(String code) {

                List<File> pluginPaths = this.getAddonFolders();

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

                        if (pluginPaths.get(i).getName().equals(code)) {

                                return pluginPaths.get(i);

                        }

                }

                return null;

        }

        public List<byte[]> getPublicKeys() {

                byte[] rawkey;

                try {

                        InputStream is = this.getClass().getResourceAsStream("/org/gvsig/installer/lib/keys/key.public");

                        rawkey = new byte[is.available()];

                        is.read(rawkey);

                        is.close();

                } catch (IOException e) {

                        return null;

                }

                List<byte[]> keys = new ArrayList<byte[]>();

                keys.add(rawkey);

                return keys;

        }

        public boolean hasProviderToThisPackage(PackageInfo packageInfo) {

                InstallerProviderManager provmgr = (InstallerProviderManager) this.getProviderManager();

                try {

                        return provmgr.getProviderFactory(packageInfo.getType())!=null;

                } catch (Exception e) {

                        return false;

                }

        }

}