org/objectweb/proactive/core/xml/VariableContract.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *  
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.core.xml;

import java.io.FileInputStream;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.log4j.Logger;
import org.objectweb.proactive.core.descriptor.xml.VariablesHandler;
import org.objectweb.proactive.core.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;
import org.xml.sax.SAXException;


public class VariableContract implements Serializable {
    static Logger logger = ProActiveLogger.getLogger(Loggers.DEPLOYMENT);
    public static VariableContract xmlproperties = null;
    public static final Lock lock = new Lock();
    private boolean closed;
    
    private static final Pattern variablePattern = Pattern.compile("(\\$\\{(.*?)\\})");
    private static final Pattern legalPattern = Pattern.compile("^\\$\\{[\\w\\.]+\\}$");
    
    private class PropertiesDatas {
        public String value;
        public VariableContractType type;
        public String setFrom; //Descriptor, Program

        public String toString() {
            StringBuilder sb = new StringBuilder();

            sb.append(value).append(" type=").append(type).append(" setFrom=")
              .append(setFrom);
            return sb.toString();
        }
    }

    private HashMap list;

    public VariableContract() {
        list = new HashMap();
        closed = false;
    }

    public void close() {
                closed = true;
        }

    public boolean isClosed() {
        return closed;
    }

    public void setVariableFromProgram(String name, String value,
        VariableContractType type) {
        setVariableFrom(name, value, type, "Program");
        setFromJavaProperty(name, type);
    }

    public void setJavaPropertiesValues(){
        //before closing we set the JavaProperties values
                java.util.Iterator it = list.keySet().iterator();
                while (it.hasNext()) {
                        String name = (String) it.next();
                        PropertiesDatas data = (PropertiesDatas) list.get(name);
                        setFromJavaProperty(name, data.type);
                }// while
    }
    
    public void setFromJavaProperty(String name, VariableContractType type){
        
        if(!type.hasSetAbility("JavaProperty")) return;
        
        try {
                        String value = System.getProperty(name);
                        if(logger.isDebugEnabled()){
                                logger.debug("Found java property "+name+"="+value);
                        }
                        if (value == null) value="";
                        setVariableFrom(name, value, type, "JavaProperty");
                } catch (Exception ex) {
                        if (logger.isDebugEnabled())
                                logger.debug("Unable to get java property: " + name);
                }
    }
    
    private void setVariableFrom(String name, String value,
        VariableContractType type, String from) {
        if (logger.isDebugEnabled()) {
            logger.debug("Setting from " + from + ": " + type + " " + name +
                "=" + value);
        }

        if (closed) {
            throw new IllegalArgumentException(
                "Variable Contract is Closed. Variables can no longer be set");
        }

        checkGenericLogic(name, value, type);

        if ((value.length() > 0) && !type.hasSetAbility(from)) {
            throw new IllegalArgumentException("Variable " + name +
                " can not be set from " + from + " for type: " + type);
        }

        if ((value.length() <= 0) && !type.hasSetEmptyAbility(from)) {
            throw new IllegalArgumentException("Variable " + name +
                " can not be set empty from " + from + " for type: " + type);
        }

        if (list.containsKey(name)) {
            PropertiesDatas var = (PropertiesDatas) list.get(name);

            if (!type.hasPriority(var.setFrom, from)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Skipping, lower priority (" + from + " < " +
                        var.setFrom + ") for type: " + type);
                }
                return;
            }
        }

        unsafeAdd(name, value, type, from);
    }

    public void setVariableFromProgram(HashMap map, VariableContractType type)
        throws NullPointerException {
        if ((map == null) || (type == null)) {
            throw new NullPointerException("Null arguments");
        }

        String name;
        java.util.Iterator it = map.keySet().iterator();
        while (it.hasNext()) {
            name = (String) it.next();
            setVariableFromProgram(name, (String) map.get(name), type);
        }
    }

    public void setDescriptorVariable(String name, String value,
        VariableContractType type) {
        
        setVariableFrom(name, value, type, "Descriptor");
        setFromJavaProperty(name, type);
    }
    
    public void load(String file) throws org.xml.sax.SAXException {
        Properties properties = new Properties();
        if (logger.isDebugEnabled()) {
            logger.debug("Loading propeties file:" + file);
        }

        // Open the file
        try {
            FileInputStream stream = new FileInputStream(file);
            properties.load(stream);
        } catch (Exception ex) {
            if (logger.isDebugEnabled()) {
                logger.debug("Curret Working Directory: " +
                    System.getProperty("user.dir"));
            }

            throw new org.xml.sax.SAXException(
                "Tag property cannot open file : [" + file + "]");
        }

        String name;
        String value;
        Iterator it = properties.keySet().iterator();
        while (it.hasNext()) {
            name = (String) it.next();
            value = properties.getProperty(name);
            setDescriptorVariable(name, value,
                VariableContractType.DescriptorVariable);
        }
    }

    public void loadXML(String file) {
        if (logger.isDebugEnabled()) {
            logger.debug("Loading XML variable file:" + file);
        }
        VariablesHandler.createVariablesHandler(file, this);
    }

    public String getValue(String name) {
        if (list.containsKey(name)) {
            PropertiesDatas var = (PropertiesDatas) list.get(name);

            return var.value;
        }

        return null;
    }

    public String transform(String text) throws SAXException {
        if(text==null) return null;
        
        Matcher m=variablePattern.matcher(text);
        StringBuffer sb=new StringBuffer();
        while(m.find()){

                if(!isLegalName(m.group(1)))
                        throw new SAXException("Error, malformed variable:"+m.group(1));
                
                String name=m.group(2);
                String value=getValue(name);

                if(value==null || value.length()<=0)
                        throw new SAXException("Error, variable value not found: "+name+"=?");
                        
                if(logger.isDebugEnabled()){
                        logger.debug("Matched:"+name+" = "+value);
                        //logger.debug(m);
                }
                m.appendReplacement(sb, value);
        }
        m.appendTail(sb);
        
        return sb.toString();
    }

    private void checkGenericLogic(String name, String value,
        VariableContractType type) {

        /*
         * Generic Logical checks
         */
        if (name == null) {
            throw new NullPointerException("Variable Name is null.");
        }

        if (name.length() <= 0) {
            throw new IllegalArgumentException("Variable Name is empty.");
        }

        if (!isLegalName("${"+name+"}")) {
            throw new IllegalArgumentException("Illegal variable name:"+name);
        }

        
        if (value == null) {
            throw new NullPointerException("Variable Value is null.");
        }

        if (type == null) {
            throw new NullPointerException("Variable Type is null.");
        }
        
        if (list.containsKey(name) &&
                !((PropertiesDatas) list.get(name)).type.equals(type)) {
            throw new IllegalArgumentException("Variable " + name +
                " is already defined with type: " +
                ((PropertiesDatas) list.get(name)).type);
        }

    }

    private void unsafeAdd(String name, String value,
        VariableContractType type, String setFrom)
        throws NullPointerException, IllegalArgumentException {
        if (name == null) {
            throw new NullPointerException("XML Variable Name is null.");
        }
        if (name.length() <= 0) {
            throw new IllegalArgumentException("XML Variable Name is empty.");
        }
        if (value == null) {
            throw new NullPointerException("XML Variable Value is null.");
        }

        PropertiesDatas data;
        if (list.containsKey(name)) {
            data = (PropertiesDatas) list.get(name);
            if (logger.isDebugEnabled()) {
                logger.debug("...Modifying variable registry: "+name+"="+value);
            }
        } else {
            data = new PropertiesDatas();
            if (logger.isDebugEnabled()) {
                logger.debug("...Creating new registry for variable: "+name+"="+value);
            }
        }

        data.type = type;
        data.value = value;
        data.setFrom = setFrom;
        list.put(name, data);
    }

    public boolean checkContract() {
        boolean retval = true;
        String name;
        java.util.Iterator it = list.keySet().iterator();
        while (it.hasNext()) {
            name = (String) it.next();
            PropertiesDatas data = (PropertiesDatas) list.get(name);

            if(data.value.length()<=0){
                logger.error(data.type.getEmptyErrorMessage(name));
                retval=false;
            }
        }

        return retval;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();

        PropertiesDatas var;
        String name;
        java.util.Iterator it = list.keySet().iterator();
        while (it.hasNext()) {
            name = (String) it.next();
            var = (PropertiesDatas) list.get(name);

            sb.append(name).append("=").append(var).append("\n");
        }

        return sb.toString();
    }
    
        public boolean isLegalName(String var){
                Matcher  m = legalPattern.matcher(var);
                return m.matches();
        }
    
/*
    public void setDescriptorVariableOLD(String name, String value,
        VariableContractType type) {
        if (logger.isDebugEnabled()) {
            logger.debug("Setting from descriptor: " + type + " " + name + "=" +
                value + ".");
        }

        checkGenericLogic(name, value, type);

        /* DescriptorVariable
         *  -Priority: XML
         *  -Set Ability: XML
         *  -Default: XML
     
        if (type.equals(VariableContractType.DescriptorVariable) &&
                (value.length() <= 0)) {
            throw new IllegalArgumentException("Variable " + name +
                " value must be specified for type: " + type);
        }

        /* ProgramVariable
         *  -Priority: Program
         *  -Set Ability: Program
         *  -Default: Program
       
        if (type.equals(VariableContractType.ProgramVariable)) {
            if (value.length() > 0) {
                throw new IllegalArgumentException("Variable " + name +
                    " can not be set from descriptor for type: " + type);
            }

            if (list.containsKey(name)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Skipping " + type + " " + name + "=" + value +
                        ". Program already set variable with value.");
                }
                return;
            }
        }

        /* DescriptorDefaultVariable
         *  -Priority: Program
         *  -Set Ability: Program, XML
         *  -Default: XML
      
        if (type.equals(VariableContractType.DescriptorDefaultVariable)) {
            if (value.length() < 0) {
                throw new IllegalArgumentException("Variable " + name +
                    " value must be specified for type: " + type);
            }

            //Priority is lost if Program set the variable
            if (list.containsKey(name)) {
                PropertiesDatas var = (PropertiesDatas) list.get(name);

                //skipe if program already set a value
                if (var.setFrom.equals("Program") && (var.value.length() > 0)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Skipping variable " + name + " type: " +
                            type +
                            ". Program already set variable with higher priority");
                    }
                    return;
                }
            }
        }

        /* ProgramDefaultVariable
         *  -Priority: XML
         *  -Set Ability: Program, XML
         *  -Default: Program
     
        if (type.equals(VariableContractType.ProgramDefaultVariable) &&
                (value.length() <= 0)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Variable " + name +
                    ", not setting to empty value");
            }
            return;
        }

        /* JavaPropertyVariable
         *  -Priority: JavaProperty
         *  -Set Ability: JavaProperty
         *  -Default: JavaProperty

        if (type.equals(VariableContractType.JavaPropertyVariable)) {
            String prop_value = null;

            if (value.length() <= 0) {
                throw new IllegalArgumentException("Variable " + name +
                    " value can not be empty for type " + type);
            }

            try {
                prop_value = System.getProperty(value);
                if (prop_value == null) {
                    throw new Exception();
                }
            } catch (Exception ex) {
                throw new IllegalArgumentException(
                    "Unable to get System Property: " + value);
            }

            value = prop_value;
        }

        //defineVariable(type, name);
        unsafeAdd(name, value, type, "Descriptor");
    }
    */
/*
    public void setVariableFromProgramOLD(String name, String value,
        VariableContractType type)
        throws NullPointerException, IllegalArgumentException {
        if (logger.isDebugEnabled()) {
            logger.debug("Setting from program:    " + type + " " + name + "=" +
                value);
        }

        checkGenericLogic(name, value, type);

        // DescriptorVariable        *  -Priority: XML         *  -Set Ability: XML        *  -Default: XML         
        if (type.equals(VariableContractType.DescriptorVariable)) {
            if (value.length() > 0) {
                throw new IllegalArgumentException("Variable " + name +
                    " can not be set from program for type: " + type);
            }

            if (list.containsKey(name)) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Skipping " + type + " " + name + "=" + value +
                        ". Descriptor already set variable with value.");
                }
                return;
            }
        }

        // ProgramVariable         *  -Priority: Program         *  -Set Ability: Program         *  -Default: Program         
        if (type.equals(VariableContractType.ProgramVariable) &&
                (value.length() <= 0)) {
            throw new IllegalArgumentException("Variable " + name +
                " value must be specified for type: " + type);
        }

        // DescriptorDefaultVariable         *  -Priority: Program         *  -Set Ability: Program, XML         *  -Default: XML         
        if (type.equals(VariableContractType.DescriptorDefaultVariable) &&
                (value.length() <= 0)) {
            if (logger.isDebugEnabled()) {
                logger.debug("Variable " + name +
                    ", not setting to empty value");
            }
            return;
        }

        // ProgramDefaultVariable          *  -Priority: XML         *  -Set Ability: Program, XML         *  -Default: Program         
        if (type.equals(VariableContractType.ProgramDefaultVariable)) {
            if (value.length() < 0) {
                throw new IllegalArgumentException("Variable " + name +
                    " value must be specified for type: " + type);
            }

            if (list.containsKey(name)) {
                PropertiesDatas var = (PropertiesDatas) list.get(name);

                //skipe if descriptor already set a value
                if (var.setFrom.equals("Descriptor") &&
                        (var.value.length() > 0)) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Skipping variable " + name + " type: " +
                            type +
                            ". Descriptor already set variable with higher priority");
                    }
                    return;
                }
            }
        }

        // JavaPropertyVariable         *  -Priority: JavaProperty         *  -Set Ability: JavaProperty         *  -Default: JavaProperty         
        if (type.equals(VariableContractType.JavaPropertyVariable)) {
            String prop_value = null;

            if (value.length() <= 0) {
                throw new IllegalArgumentException("Variable " + name +
                    " value can not be empty for type " + type);
            }

            try {
                prop_value = System.getProperty(value);
                if (prop_value == null) {
                    throw new Exception();
                }
            } catch (Exception ex) {
                throw new IllegalArgumentException(
                    "Unable to get System Property: " + value);
            }

            value = prop_value;
        }

        //defineVariable(type, name);
        unsafeAdd(name, value, type, "Program");
    }
*/
    static public class Lock {
        private boolean locked;

        private Lock() {
            locked = false;
        }

        public synchronized void release() {
            locked = false;
            notify();
        }

        public synchronized void aquire() {
            while (locked) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }

            locked = true;
        }
    }
}

---