XMLRuleDAO.java
/*
* This file is part of Waarp Project (named also Waarp or GG).
*
* Copyright (c) 2019, Waarp SAS, and individual contributors by the @author
* tags. See the COPYRIGHT.txt in the distribution for a full listing of
* individual contributors.
*
* All Waarp Project 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.
*
* Waarp 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
* Waarp . If not, see <http://www.gnu.org/licenses/>.
*/
package org.waarp.openr66.dao.xml;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.waarp.common.database.exception.WaarpDatabaseSqlException;
import org.waarp.common.logging.WaarpLogger;
import org.waarp.common.logging.WaarpLoggerFactory;
import org.waarp.common.xml.XmlUtil;
import org.waarp.openr66.configuration.ExtensionFilter;
import org.waarp.openr66.dao.Filter;
import org.waarp.openr66.dao.RuleDAO;
import org.waarp.openr66.dao.exception.DAOConnectionException;
import org.waarp.openr66.dao.exception.DAONoDataException;
import org.waarp.openr66.pojo.Rule;
import org.waarp.openr66.pojo.RuleTask;
import org.waarp.openr66.protocol.configuration.Configuration;
import org.xml.sax.SAXException;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import static org.waarp.openr66.dao.DAOFactory.*;
import static org.waarp.openr66.dao.database.DBRuleDAO.*;
public class XMLRuleDAO implements RuleDAO {
private static final WaarpLogger logger =
WaarpLoggerFactory.getLogger(XMLRuleDAO.class);
/**
* HashTable in case of lack of database
*/
private static final ConcurrentHashMap<String, Rule> dbR66RuleHashMap =
new ConcurrentHashMap<String, Rule>();
public static final String ROOT_LIST = "rules";
private static final String XML_GET_ALL = "//rule";
private static final File[] FILE_0_LENGTH = new File[0];
public XMLRuleDAO() {
// Nothing to do
}
@Override
public final void close() {
// ignore
}
public static final String EXT_RULE = ".rule.xml";
public static final String EXT_RULES = ".rules.xml";
private File[] getRuleFiles() {
final File ruleDir = new File(
Configuration.configuration.getBaseDirectory() +
Configuration.configuration.getConfigPath());
final List<File> res = new ArrayList<File>();
if (ruleDir.isDirectory()) {
res.addAll(
Arrays.asList(ruleDir.listFiles(new ExtensionFilter(EXT_RULE))));
res.addAll(
Arrays.asList(ruleDir.listFiles(new ExtensionFilter(EXT_RULES))));
}
return res.toArray(FILE_0_LENGTH);
}
@Override
public final void delete(final Rule rule) {
dbR66RuleHashMap.remove(rule.getName());
}
@Override
public final void deleteAll() {
dbR66RuleHashMap.clear();
}
@Override
public final List<Rule> getAll() throws DAOConnectionException {
final List<Rule> res = new ArrayList<Rule>();
final File[] files = getRuleFiles();
for (final File ruleFile : files) {
logger.debug("Load file {}", ruleFile.getAbsolutePath());
try {
final DocumentBuilderFactory dbf = getDocumentBuilderFactory();
final Document document = dbf.newDocumentBuilder().parse(ruleFile);
// Setup XPath query
final XPath xPath = XPathFactory.newInstance().newXPath();
final XPathExpression xpe = xPath.compile(XML_GET_ALL);
final NodeList listNode =
(NodeList) xpe.evaluate(document, XPathConstants.NODESET);
// Iterate through all found nodes
for (int i = 0; i < listNode.getLength(); i++) {
final Node node = listNode.item(i);
final Rule rule = getFromNode(node);
res.add(rule);
dbR66RuleHashMap.put(rule.getName(), rule);
}
} catch (final SAXException e) {
throw new DAOConnectionException(e);
} catch (final XPathExpressionException e) {
throw new DAOConnectionException(e);
} catch (final ParserConfigurationException e) {
throw new DAOConnectionException(e);
} catch (final IOException e) {
throw new DAOConnectionException(e);
} catch (final Exception e) {
throw new DAOConnectionException(e);
}
}
return res;
}
/**
* {@link DAOConnectionException}
*
* @return count only if filters is empty or null
*/
@Override
public final long count(final List<Filter> fitlers)
throws DAOConnectionException {
if (fitlers == null || fitlers.isEmpty()) {
return dbR66RuleHashMap.size();
}
throw new DAOConnectionException("Operation not supported on XML DAO");
}
@Override
public final boolean exist(final String rulename) {
return dbR66RuleHashMap.containsKey(rulename);
}
@Override
public final List<Rule> find(final List<Filter> fitlers)
throws DAOConnectionException {
throw new DAOConnectionException("Operation not supported on XML DAO");
}
@Override
public List<Rule> find(final List<Filter> filters, final int limit)
throws DAOConnectionException {
throw new DAOConnectionException("Operation not supported on XML DAO");
}
@Override
public List<Rule> find(final List<Filter> filters, final String field,
final boolean asc) throws DAOConnectionException {
throw new DAOConnectionException("Operation not supported on XML DAO");
}
@Override
public List<Rule> find(final List<Filter> filters, final String field,
final boolean asc, final int limit)
throws DAOConnectionException {
throw new DAOConnectionException("Operation not supported on XML DAO");
}
@Override
public List<Rule> find(final List<Filter> filters, final String field,
final boolean asc, final int limit, final int offset)
throws DAOConnectionException {
throw new DAOConnectionException("Operation not supported on XML DAO");
}
@Override
public void update(final List<Filter> filters, final String toSet)
throws DAOConnectionException {
throw new DAOConnectionException("Operation not supported on XML DAO");
}
@Override
public final void insert(final Rule rule) {
dbR66RuleHashMap.put(rule.getName(), rule);
}
@Override
public final Rule select(final String rulename)
throws DAOConnectionException, DAONoDataException {
if (exist(rulename)) {
return dbR66RuleHashMap.get(rulename);
}
throw new DAONoDataException("Rule cannot be found");
}
@Override
public final void update(final Rule rule) {
dbR66RuleHashMap.put(rule.getName(), rule);
}
private Rule getFromNode(final Node parent) throws DAOConnectionException {
final Rule res = new Rule();
final NodeList children = parent.getChildNodes();
for (int j = 0; j < children.getLength(); j++) {
final Node node = children.item(j);
final String content = XmlUtil.getExtraTrimed(node.getTextContent());
if (node.getNodeName().equals(ID_FIELD)) {
res.setName(content);
} else if (node.getNodeName().equals(HOSTIDS_FIELD)) {
res.setHostids(retrieveHostids(node));
} else if (node.getNodeName().equals(MODE_TRANS_FIELD)) {
res.setMode(Integer.parseInt(content));
} else if (node.getNodeName().equals(SEND_PATH_FIELD)) {
try {
res.setSendPath(content);
} catch (final WaarpDatabaseSqlException e) {
throw new DAOConnectionException(e);
}
} else if (node.getNodeName().equals(RECV_PATH_FIELD)) {
try {
res.setRecvPath(content);
} catch (final WaarpDatabaseSqlException e) {
throw new DAOConnectionException(e);
}
} else if (node.getNodeName().equals(ARCHIVE_PATH_FIELD)) {
try {
res.setArchivePath(content);
} catch (final WaarpDatabaseSqlException e) {
throw new DAOConnectionException(e);
}
} else if (node.getNodeName().equals(WORK_PATH_FIELD)) {
try {
res.setWorkPath(content);
} catch (final WaarpDatabaseSqlException e) {
throw new DAOConnectionException(e);
}
} else if (node.getNodeName().equals(R_PRE_TASKS_FIELD)) {
res.setRPreTasks(retrieveTasks(node));
} else if (node.getNodeName().equals(R_POST_TASKS_FIELD)) {
res.setRPostTasks(retrieveTasks(node));
} else if (node.getNodeName().equals(R_ERROR_TASKS_FIELD)) {
res.setRErrorTasks(retrieveTasks(node));
} else if (node.getNodeName().equals(S_PRE_TASKS_FIELD)) {
res.setSPreTasks(retrieveTasks(node));
} else if (node.getNodeName().equals(S_POST_TASKS_FIELD)) {
res.setSPostTasks(retrieveTasks(node));
} else if (node.getNodeName().equals(S_ERROR_TASKS_FIELD)) {
res.setSErrorTasks(retrieveTasks(node));
}
}
return res;
}
private List<String> retrieveHostids(final Node xml)
throws DAOConnectionException {
final ArrayList<String> res = new ArrayList<String>();
if (xml == null || !xml.hasChildNodes()) {
return res;
}
final NodeList hostsList = xml.getChildNodes();
for (int i = 0; i < hostsList.getLength(); i++) {
res.add(XmlUtil.getExtraTrimed(hostsList.item(i).getTextContent()));
}
return res;
}
private List<RuleTask> retrieveTasks(final Node src) {
final List<RuleTask> res = new ArrayList<RuleTask>();
final NodeList feed = src.getChildNodes();
for (int i = 0; i < feed.getLength(); i++) {
final Node mainnode = feed.item(i);
if (mainnode.getNodeType() == Node.ELEMENT_NODE) {
final Element e = (Element) mainnode;
final NodeList tasksList = e.getElementsByTagName(TASK_NODE);
for (int j = 0; j < tasksList.getLength(); j++) {
final Node taskNode = tasksList.item(j);
if (taskNode.getNodeType() == Node.ELEMENT_NODE) {
final Element task = (Element) taskNode;
NodeList nodeList = task.getElementsByTagName(TYPE_FIELD);
if (nodeList == null || nodeList.getLength() == 0) {
logger.error("Field not found in Rule: " + TYPE_FIELD);
continue;
}
final String type =
XmlUtil.getExtraTrimed(nodeList.item(0).getTextContent());
nodeList = task.getElementsByTagName(PATH_FIELD);
final String path;
if (nodeList != null && nodeList.getLength() > 0) {
path = XmlUtil.getExtraTrimed(nodeList.item(0).getTextContent());
} else {
path = "";
}
nodeList = task.getElementsByTagName(DELAY_FIELD);
final int delay;
if (nodeList != null && nodeList.getLength() > 0) {
int tmpDelay = 0;
try {
tmpDelay = Integer.parseInt(
XmlUtil.getExtraTrimed(nodeList.item(0).getTextContent()));
} catch (final NumberFormatException ignored) {
// ignore
}
delay = tmpDelay;
} else {
delay = 0;
}
final RuleTask ruleTask = new RuleTask(type, path, delay);
logger.debug("Task {}", ruleTask);
res.add(ruleTask);
}
}
}
}
return res;
}
}