gvSIG projects pool

package org.gvsig.jvmpreferences.nativeprefs;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.lang.management.ManagementFactory;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import javax.management.AttributeNotFoundException;

import javax.management.InstanceNotFoundException;

import javax.management.MBeanException;

import javax.management.MBeanServer;

import javax.management.MalformedObjectNameException;

import javax.management.ObjectName;

import javax.management.ReflectionException;

import org.gvsig.i18n.Messages;

import org.gvsig.jvmpreferences.nativeprefs.MemoryPreferences;

import org.slf4j.LoggerFactory;

/**

 * This class abstracts the complexity of reading/storing

 * memory preferences for different operating systems

 * 

 * @author Cesar Martinez Izquierdo

 *

 */

public abstract class BaseMemoryPreferences implements MemoryPreferences {

        public static final int FACTORY_DEFAULT_MAXIMUM = 512;

        /* (non-Javadoc)

         * @see org.gvsig.preferences.nativeprefs.general.memory.MemoryPreferences#getConfigFile()

         */

        public abstract File getConfigFile();

        /* (non-Javadoc)

         * @see org.gvsig.preferences.nativeprefs.general.memory.MemoryPreferences#isConfigWritable()

         */

        public boolean isConfigWritable(){

                return getConfigFile().canWrite();

        }

        /* (non-Javadoc)

         * @see org.gvsig.preferences.nativeprefs.general.memory.MemoryPreferences#getTotalSystemMemory()

         */

        public int getTotalSystemMemory() {

                MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();

                Object attribute;

                try {

                        attribute = mBeanServer.getAttribute(new ObjectName("java.lang","type","OperatingSystem"), "TotalPhysicalMemorySize");

                        System.out.println("Total memory: "+ attribute.toString() +" B");

                        System.out.println("Total memory: "+ Long.parseLong(attribute.toString())/(1024*1024) +" MB");

                        return (int) (Long.parseLong(attribute.toString())/(1024*1024));

                } catch (AttributeNotFoundException e) {

                        LoggerFactory.getLogger(BaseMemoryPreferences.class).error("Total_system_memory_cant_be_retrived", e);

                } catch (InstanceNotFoundException e) {

                        LoggerFactory.getLogger(BaseMemoryPreferences.class).error("Total_system_memory_cant_be_retrived", e);

                } catch (MalformedObjectNameException e) {

                        LoggerFactory.getLogger(BaseMemoryPreferences.class).error("Total_system_memory_cant_be_retrived", e);

                } catch (MBeanException e) {

                        LoggerFactory.getLogger(BaseMemoryPreferences.class).error("Total_system_memory_cant_be_retrived", e);

                } catch (ReflectionException e) {

                        LoggerFactory.getLogger(BaseMemoryPreferences.class).error("Total_system_memory_cant_be_retrived", e);

                } catch (NullPointerException e) {

                        LoggerFactory.getLogger(BaseMemoryPreferences.class).error("Total_system_memory_cant_be_retrived", e);

                }

                return 512;

        }

        /* (non-Javadoc)

         * @see org.gvsig.preferences.nativeprefs.general.memory.MemoryPreferences#getSafeMemoryMaximum()

         */

        public int getSafeMemoryMaximum() {

                int totalMemory = getTotalSystemMemory();

                if (totalMemory<=1024) {

                        return (int)(0.6*(float)totalMemory);

                }

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

                if ("x86".equals(arch) || "i386".equals(arch)) {

                        return 1200;

                }

                return (totalMemory-768);

        }

        /* (non-Javadoc)

         * @see org.gvsig.preferences.nativeprefs.general.memory.MemoryPreferences#readConfiguredMaximum()

         */

        public int readConfiguredMaximum() {

                File launcherFile = getConfigFile();

                if (launcherFile.exists()) {

                        BufferedReader reader = null;

                        try {

                                reader = new BufferedReader(new FileReader(launcherFile));

                                String line;

                                Pattern pattern = Pattern.compile(getMaxMemoryRegexp());

                                while ((line = reader.readLine())!=null) {

                                        Matcher m = pattern.matcher(line);

                                        if (m.matches()) {

                                                String memoryStr=m.group(1);

                                                String units = m.group(2);

                                                int configMemory;

                                                try {

                                                        // first of all assume it does not have units

                                                        configMemory = Integer.parseInt(memoryStr);

                                                        System.out.println("Configured memory: " + configMemory);

                                                        if (units!=null) {

                                                                units = units.toLowerCase();

                                                                if ("g".equals(units)) {

                                                                        configMemory = configMemory * 1024;

                                                                }

                                                                else if ("k".equals(units)) {

                                                                        configMemory = (int)((float)configMemory/1024.0);

                                                                }

                                                        }

                                                        return configMemory;

                                                }

                                                catch (NumberFormatException ex) {

                                                }

                                        }

                                }

                        } catch (FileNotFoundException e) {

                                LoggerFactory.getLogger(this.getClass()).error(Messages.getText("Memory_config_could_not_be_retrived"), e);

                        } catch (NumberFormatException e) {

                                LoggerFactory.getLogger(this.getClass()).error(Messages.getText("Memory_config_could_not_be_retrived"), e);

                        } catch (IOException e) {

                                LoggerFactory.getLogger(this.getClass()).error(Messages.getText("Memory_config_could_not_be_retrived"), e);

                        }

                        finally {

                                try {

                                        if (reader!=null) {

                                                reader.close();

                                        }

                                } catch (IOException e) {

                                }

                        }

                }

                LoggerFactory.getLogger(this.getClass()).error(Messages.getText("Memory_config_could_not_be_retrived"));

                return getSafeMemoryMaximum();

        }

        /**

         * Copies one file. We are not using

         * {@link org.gvsig.utils.FileUtils#copy(File, File)} method

         * because it does not use buffered reader. Probably it should be corrected

         * there and removed from here

         * 

         * @param src The file to copy

         * @param dst The destination file

         * @throws IOException

         */

    public static void copy(File src, File dst) throws IOException {

        InputStream in = new BufferedInputStream(new FileInputStream(src));

        OutputStream out = new BufferedOutputStream(new FileOutputStream(dst));

        // Transfer bytes from in to out

        byte[] buf = new byte[10240];

        int len;

        while ((len = in.read(buf)) > 0) {

            out.write(buf, 0, len);

        }

        in.close();

        out.close();

    }

        /* (non-Javadoc)

         * @see org.gvsig.preferences.nativeprefs.general.memory.MemoryPreferences#saveConguredMaximum()

         */

        public void saveConguredMaximum(int maximumMemory) {

                File launcherFile = getConfigFile();

                if (launcherFile.exists()) {

                        SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmssSSS");

                        String date = format.format(new Date());

                        File backupFile = new File(launcherFile.getAbsolutePath()+"-"+date+".bak");

                        BufferedWriter writer = null;

                        BufferedReader reader = null;

                        try {

                                copy(launcherFile, backupFile);

                                writer = new BufferedWriter(new FileWriter(launcherFile));

                                reader = new BufferedReader(new FileReader(backupFile));

                                String line;

                                Pattern pattern = Pattern.compile(getMaxMemoryRegexp());

                                boolean written = false;

                                while ((line = reader.readLine())!=null) {

                                        if (!pattern.matcher(line).matches() || written) {

                                                writer.write(line);

                                                writer.write(getNewLineChars());

                                        }

                                        else {

                                                written = true; // avoid writing the mem line twice

                                                writer.write(getEncodedMaxMemoryLine(maximumMemory));

                                                writer.write(getNewLineChars());

                                        }

                                }

                        } catch (FileNotFoundException e) {

                                LoggerFactory.getLogger(this.getClass()).error(Messages.getText("Memory_config_could_not_be_written"), e);

                        } catch (IOException e) {

                                LoggerFactory.getLogger(this.getClass()).error(Messages.getText("Memory_config_could_not_be_written"), e);

                        }

                        finally {

                                if (reader!=null) {

                                        try {

                                                reader.close();

                                        } catch (IOException e) {

                                                LoggerFactory.getLogger(this.getClass()).debug(Messages.getText("Error_closing_reader"), e);

                                        }

                                }

                                if (writer!=null) {

                                        try {

                                                writer.close();

                                        } catch (IOException e) {

                                                LoggerFactory.getLogger(this.getClass()).debug(Messages.getText("Error_closing_writer"), e);

                                        }

                                }

                        }

                }

        }

        /**

         * A valid Java regular expression that matches the line

         * containing the maximum memory parameter (-Xmx) parameter

         * on the launcher file for this platform.

         * 

         * The regular expression must contain 2 capturing groups,

         * the first one capturing the numeric part and the second

         * one capturing the units.

         * 

         * E.g. for the definition -Xmx1024M,

         * the first group must capture '1024', while the second

         * group must capture the 'M'.

         * 

         * Note that the units may be absent in the definition string.

         * 

         * @return A valid Java regular expression

         */

        protected abstract String getMaxMemoryRegexp();

        /**

         * Encodes the maximum memory parameter (-Xmx) in a suitable format

         * for being directly written on the launcher configuration files

         * for this platform.

         *  

         * @param maximumMemory

         * @return

         */

        protected abstract String getEncodedMaxMemoryLine(int maximumMemory);

        /**

         * Gets the character(s) used as line separators. We don't use the "line.separator"

         * Java property because we currently must use the Unix-style separator even in Windows,

         * and this might change in the future.

         * @return

         */

        protected abstract String getNewLineChars();

        public int getFactoryDefaultMaximum() {

                return FACTORY_DEFAULT_MAXIMUM;

        }

}