ContextFactory.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package org.turro.elephant.impl.context;
 
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.xpath.XPath;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.IAction;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.context.IContext;
import org.turro.elephant.context.IElement;
import org.turro.elephant.context.IImplementation;
import org.turro.elephant.impl.abstracts.AbstractElement;
import org.turro.reflection.Reflections;
 
public class ContextFactory {
 
  private ContextFactory() {
  }
 
  public static IContext getContext(IConstructor constructor) {
    return getContext(constructor, null);
  }
 
  public static IContext getContext(IConstructor constructor, String path) {
    IContext impl = new DefaultContext(); //(IContext) getInstance("context", DefaultContext.class);
    if(impl != null) {
      impl.setConstructor(constructor, path);
    }
    return impl;
  }
 
  public static IElement getContextElement(IContext context, Element node) {
    return getContextElement(context, node.getAttributeValue("type"), node);
  }
 
  public static IElement getContextElement(IContext context, String type, Element node) {
    IElement impl = null;
    Element element = null;
    if(!"none".equals(type)) {
      element = getConfNode("elements/element[@type='" + type + "']");
    }
    if(element != null) {
      try {
        String jClass = element.getAttributeValue("java-class");
        Class cls = Class.forName(makeItTurro(jClass));
        if(cls != null) {
          Constructor cons = cls.getConstructor(new Class[] {});
          if(cons != null) {
            impl = (IElement)cons.newInstance(new Object[] {});
          }
        }
      } catch(ClassNotFoundException | NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
        Logger.getLogger(ContextFactory.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    }
    if(impl instanceof AbstractElement) {
      ((AbstractElement) impl).setConfiguration(node, element);
      //impl.setContext(context);
    }
    return impl;
  }
 
  public static IAction getAction(IConstructor constructor) {
    IAction impl = null;
    String type = constructor.getRequest().getServletPath().substring(9);
    Element element = getConfNode("actions/action[@type='" + type + "']");
    if(element != null) {
      try {
        String jClass = element.getAttributeValue("java-class");
        Class cls = Class.forName(makeItTurro(jClass));
        if(cls != null) {
          Constructor cons = cls.getConstructor(new Class[] {});
          if(cons != null) {
            impl = (IAction)cons.newInstance(new Object[] {});
          }
        }
      } catch(Exception ex) {
        Logger.getLogger(ContextFactory.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    }
    if(impl != null) {
      impl.setConstructor(constructor);
    }
    return impl;
  }
 
  public static Element getInclude(IConstructor constructor) {
    String type = constructor.getRequest().getServletPath();
    return getConfNode("includes/include[@type='" + type + "']");
  }
 
  public static Element getRedirection(String path) {
    return getConfNode("redirections/redirect[@request and starts-with('" + path + "',@request)]");
  }
 
  public static Element getVirtual(String server) {
    return getConfNode("virtuals/virtual[@server='" + server + "']");
  }
 
  public static List getImplementationNamesByType(String type) {
    List list = new ArrayList();
    for(Element element : (List<Element>) getConfNodes("implementations")) {
      if(element != null) {
        try {
          Iterator it = XPath.selectNodes(element, "impl[starts-with(@interface,'" + type + "_')]/@interface").iterator();
          while(it.hasNext()) {
            list.add(((Attribute)it.next()).getValue());
          }
        } catch(Exception ex) {
          Logger.getLogger(ContextFactory.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
        }
      }
    }
    return list;
  }
 
  public static Object getImplementation(IElement iel, String name) {
    IConstructor xpcons = null;
    Object impl = null;
    if(iel != null) xpcons = iel.getConstructor();
    if(xpcons != null) {
      impl = getImplementation(xpcons, name);
      if(impl != null) {
        if(impl instanceof IImplementation) {
          ((IImplementation)impl).setElement(iel);
        }
      }
    }
    return impl;
  }
 
  public static Object getImplementation(IConstructor constructor, String name) {
    Object impl = null;
    Element element = getConfNode("implementations/impl[@interface='" + name + "']");
    if(element != null) {
      try {
        String jClass = element.getAttributeValue("java-class");
        Class cls = Class.forName(makeItTurro(jClass));
        if(cls != null) {
          Constructor cons = cls.getConstructor(new Class[] {});
          if(cons != null) {
            impl = cons.newInstance(new Object[] {});
          }
        }
      } catch(Exception ex) {
        Logger.getLogger(ContextFactory.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    }
    if(impl != null) {
      if(impl instanceof IImplementation) {
        ((IImplementation)impl).setConstructor(constructor);
        if(element != null) {
          ((IImplementation)impl).setConfiguration((Element)element.clone());
        }
      }
    }
    return impl;
  }
 
  public static Object getJavaClass(String jClass) {
    Object impl = null;
    try {
      Class cls = Class.forName(makeItTurro(jClass));
      if(cls != null) {
        Constructor cons = cls.getConstructor(new Class[] {});
        if(cons != null) {
          impl = cons.newInstance(new Object[] {});
        }
      }
    } catch(Exception ex) {
      Logger.getLogger(ContextFactory.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
    return impl;
  }
 
  public static Object getInstance(String node, Class defaultClass) {
    Constructor cons = impls.get(node);
    if(cons == null) {
      Class javaClass = null;
      Element element = getConfNode(node);
      if(element != null) {
        try {
          String jClass = element.getAttributeValue("java-class");
          javaClass = Class.forName(makeItTurro(jClass));
        } catch(Exception ex) {
          Logger.getLogger(ContextFactory.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
        }
      }
      if(javaClass == null) {
        javaClass = defaultClass;
      }
      try {
        impls.put(node, javaClass.getConstructor(new Class[] {}));
        return Reflections.of(javaClass).instance();
      } catch (Exception ex) {
        Logger.getLogger(ContextFactory.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    } else {
      try {
        return cons.newInstance(new Object[] {} );
      } catch (Exception ex) {
        Logger.getLogger(ContextFactory.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    }
    return null;
  }
  
  public static void resetImplementationsStartingWith(String name) {
    elements.entrySet().removeIf(e -> e.getKey().startsWith("implementations/impl[@interface='" + name));
  }
  
  private static Map<String, Constructor> impls = new HashMap<String, Constructor>();
  private static Map<String, Element> elements = new HashMap<String, Element>();
 
  private static String makeItTurro(String jClass) {
    return jClass.replaceAll("org\\.ao\\.", "org.turro.");
  }
  
  private static List getConfNodes(String node) {
    File configs[] = new File(ElephantContext.getRealPath("/WEB-INF/elephant/conf")).listFiles(new FilenameFilter() {
      @Override
      public boolean accept(File dir, String name) {
        return name.startsWith("elephant") && name.endsWith(".xml");
      }
    });
    List list = new ArrayList();
    for(File conf : configs) {
      Element el = getConfigurationNode(conf, node);
      if(el != null) list.add(el);
    }
    return list;
  }
 
  private static Element getConfNode(String node) {
    Element el = elements.get(node);
    if(el == null) {
      File configs[] = new File(ElephantContext.getRealPath("/WEB-INF/elephant/conf")).listFiles(new FilenameFilter() {
        @Override
        public boolean accept(File dir, String name) {
          return name.startsWith("elephant") && name.endsWith(".xml");
        }
      });
      for(File conf : configs) {
        el = getConfigurationNode(conf, node);
        if(el != null) {
          elements.put(node, el);
          break;
        }
      }
    }
    return el;
  }
 
  private static Element getConfigurationNode(File confFile, String node) {
    if(confFile.exists()) {
      Element conf = null;
      SAXBuilder builder = new SAXBuilder();
      Document doc;
      try {
        doc = builder.build(confFile);
        conf = doc.getRootElement();
      } catch (IOException | JDOMException ex) {
        Logger.getLogger(ContextFactory.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
      if(conf != null) {
        try {
          return (Element)XPath.selectSingleNode(conf, node);
        } catch(Exception ex) {
          return null;
        }
      }
    }
    return null;
  }
 
}