Application: gvSIG desktop

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * MA 02110-1301, USA.

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.util.Collection;

import java.util.Iterator;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.apache.commons.lang3.StringUtils;

        InstallerManager {

    private static class LocalRepositoryLocation {

        private File location;

        private Set<String> types;

        public LocalRepositoryLocation(File localtion, String type) {

            this.location = localtion;

            this.types = new HashSet<String>();

            this.addType(type);

        }

        public LocalRepositoryLocation(File localtion) {

            this(localtion, null);

        }

        public void addType(String type) {

            if ( !StringUtils.isBlank(type) ) {

                this.types.add(type);

            }

        }

        public void addType(LocalRepositoryLocation location) {

            this.types.addAll(location.getTypes());

        }

        public Collection<String> getTypes() {

            return this.types;

        }

        public File getLocation() {

            return this.location;

        }

        public String getDefaultType() {

            if ( this.types.isEmpty() ) {

                return null;

            }

            return this.types.iterator().next();

        }

        public boolean is(File location) {

            if ( location.equals(this.location) ) {

                return true;

            }

            return false;

        }

        public boolean contains(File file) {

            if ( file.getAbsolutePath().startsWith(this.location.getAbsolutePath()) ) {

                return true;

            }

            return false;

        }

    }

    private static class LocalRepositoriesLocations extends ArrayList<LocalRepositoryLocation> {

        public LocalRepositoryLocation getLocation(File location) {

            Iterator<LocalRepositoryLocation> it = super.iterator();

            while ( it.hasNext() ) {

                LocalRepositoryLocation x = it.next();

                if ( x.is(location) ) {

                    return x;

                }

            }

            return null;

        }

        public boolean add(LocalRepositoryLocation location) {

            LocalRepositoryLocation old = this.getLocation(location.getLocation());

            if ( old != null ) {

                old.addType(location);

                return true;

            }

            return super.add(location);

        }

    }

    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 List<LocalRepositoryLocation> localRepositoriesLocation = null;

    private File defaultRepositoryLocation = null;

    public DefaultInstallerManager() {

        super(new DefaultInstallerProviderManager());

        localRepositoriesLocation = new LocalRepositoriesLocations();

    }

    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 PackageInfo createPackageInfo(File file) throws BaseException {

        FileInputStream fis = null;

        PackageInfo pkg = null;

        try {

            fis = new FileInputStream(file);

            pkg = this.createPackageInfo(fis);

            fis.close();

        } catch (Exception ex) {

        } finally {

            try {

                fis.close();

            } catch (IOException ex) {

                //

            }

        }

        return pkg;

    }

    public URL getDownloadBaseURL() {

        return this.BaseDownloadURL;

    }

    public String getVersion() {

        return this.version.toString();

    }

    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.defaultRepositoryLocation;

    }

    public void setDefaultLocalAddonRepository(File defaultAddonsRepository) {

        this.defaultRepositoryLocation = defaultAddonsRepository;

        this.localRepositoriesLocation.add(new LocalRepositoryLocation(defaultAddonsRepository));

    }

    public void addLocalAddonRepository(File path) {

        this.addLocalAddonRepository(path, null);

    }

    public void addLocalAddonRepository(File path, String type) {

        localRepositoriesLocation.add(new LocalRepositoryLocation(path, type));

    }

    public String getDefaultLocalRepositoryType(File file) {

        Iterator<LocalRepositoryLocation> it = localRepositoriesLocation.iterator();

        while ( it.hasNext() ) {

            LocalRepositoryLocation location = it.next();

            if ( location.contains(file) ) {

                return location.getDefaultType();

            }

        }

        return null;

    }

    public List<File> getLocalAddonRepositories() {

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

        Iterator<LocalRepositoryLocation> it = localRepositoriesLocation.iterator();

        while ( it.hasNext() ) {

            l.add(it.next().getLocation());

        }

        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> packagePaths = this.getAddonFolders();

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

            try {

                File pkgfile = new File(packagePaths.get(i), "package.info");

                PackageInfo pkg = this.createPackageInfo(pkgfile);

                if ( pkg.getCode().equalsIgnoreCase(code) ) {

                    return packagePaths.get(i);

                }

            } catch (Exception ex) {

            }

        }

        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;

        }

    }