use of alma.cdbErrType.CDBRecordDoesNotExistEx in project ACS by ACS-Community.
the class ACSAlarmSystemDAOImpl method flushConfiguration.
public void flushConfiguration(AlarmSystemConfiguration asc) {
if (conf == null || !conf.isWriteable())
throw new IllegalStateException("no writable configuration accessor");
if (asc == null)
throw new IllegalArgumentException("Null Alarm System Configuration argument");
StringWriter FFWriter = new StringWriter();
Marshaller FF_marshaller;
try {
FF_marshaller = new Marshaller(FFWriter);
} catch (IOException e) {
e.printStackTrace();
return;
}
FF_marshaller.setValidation(false);
try {
FF_marshaller.marshal(asc);
} catch (MarshalException e) {
e.printStackTrace();
return;
} catch (ValidationException e) {
e.printStackTrace();
return;
}
try {
conf.deleteConfiguration(ALARM_SYSTEM_CONFIGURATION_PATH);
conf.addConfiguration(ALARM_SYSTEM_CONFIGURATION_PATH, FFWriter.toString().replaceFirst("xsi:type=\".*\"", ""));
} catch (CDBRecordDoesNotExistEx e) {
try {
conf.addConfiguration(ALARM_SYSTEM_CONFIGURATION_PATH, FFWriter.toString().replaceFirst("xsi:type=\".*\"", ""));
} catch (Exception e1) {
e1.printStackTrace();
}
} catch (org.omg.CORBA.UNKNOWN e) {
try {
conf.addConfiguration(ALARM_SYSTEM_CONFIGURATION_PATH, FFWriter.toString().replaceFirst("xsi:type=\".*\"", ""));
} catch (Exception e1) {
e1.printStackTrace();
}
} catch (Exception e) {
e.printStackTrace();
}
}
use of alma.cdbErrType.CDBRecordDoesNotExistEx in project ACS by ACS-Community.
the class DALRead method main.
public static void main(String[] args) {
Logger m_logger = ClientLogManager.getAcsLogManager().getLoggerForApplication("DALRead", false);
try {
String curl;
String strIOR = null;
boolean rawOutput = false;
if (args.length < 1) {
System.out.println("Usage: cmd curl [-d ior -raw -h]");
return;
}
curl = args[0];
// test for IOR in cmd line
for (int i = 0; i < args.length; i++) {
if (args[i].equals("-d")) {
if (i < args.length - 1) {
strIOR = args[++i];
}
}
if (args[i].equals("-raw")) {
rawOutput = true;
}
if (args[i].equals("-h")) {
System.out.println("Usage: cmd curl [-d ior -raw -h]");
return;
}
}
if (strIOR == null) {
// use default
strIOR = "corbaloc::" + InetAddress.getLocalHost().getHostName() + ":" + ACSPorts.getCDBPort() + "/CDB";
}
// create and initialize the ORB
ORB orb = ORB.init(args, null);
DAL dal = DALHelper.narrow(orb.string_to_object(strIOR));
String xml = dal.get_DAO(curl);
if (rawOutput) {
m_logger.log(AcsLogLevel.INFO, "Curl data:\n" + xml);
return;
}
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser saxParser = factory.newSAXParser();
XMLHandler xmlSolver = new XMLHandler(false, m_logger);
saxParser.parse(new InputSource(new StringReader(xml)), xmlSolver);
if (xmlSolver.m_errorString != null) {
String info = "XML parser error: " + xmlSolver.m_errorString;
AcsJCDBXMLErrorEx xmlErr = new AcsJCDBXMLErrorEx();
System.err.println(info);
throw xmlErr;
}
System.out.println("Env " + System.getProperty("HOMEPATH"));
// dump contents
System.out.println("________________________________________________________");
walk(xmlSolver.m_rootNode);
System.out.println("________________________________________________________");
} catch (AcsJCDBXMLErrorEx e) {
e.printStackTrace();
e.log(m_logger);
} catch (CDBXMLErrorEx e) {
AcsJCDBXMLErrorEx je = AcsJCDBXMLErrorEx.fromCDBXMLErrorEx(e);
String smsg = "XML Error \tCURL='" + je.getCurl() + "'\n\t\tFilename='" + je.getFilename() + "'\n\t\tNodename='" + je.getNodename() + "'\n\t\tMSG='" + je.getErrorString() + "'";
je.log(m_logger);
m_logger.log(AcsLogLevel.NOTICE, smsg, je);
} catch (CDBRecordDoesNotExistEx e) {
AcsJCDBRecordDoesNotExistEx je = AcsJCDBRecordDoesNotExistEx.fromCDBRecordDoesNotExistEx(e);
String smsg = "Record does not exist \tCURL='" + je.getCurl() + "'";
je.log(m_logger);
m_logger.log(AcsLogLevel.NOTICE, smsg, je);
} catch (Exception e) {
e.printStackTrace();
}
}
use of alma.cdbErrType.CDBRecordDoesNotExistEx in project ACS by ACS-Community.
the class HibernateWDALImpl method loadXMLCDB.
//final Integer NULL_ID = null;
protected boolean loadXMLCDB(String[] args, ORB orb, POA poa, String configName) {
m_logger.info("Reading configuration from XML CDB...");
try {
loadInProgress.set(true);
/* create new poa for xmlCDB */
org.omg.CORBA.Policy[] policies = new org.omg.CORBA.Policy[] { poa.create_id_assignment_policy(IdAssignmentPolicyValue.USER_ID) };
POA xmlCDBPOA = poa.create_POA("xmlCDBPOA", poa.the_POAManager(), policies);
for (int i = 0; i < policies.length; i++) policies[i].destroy();
// disable cache for XML CDB DAL (important)
String[] newArgs = new String[args.length + 2];
System.arraycopy(args, 0, newArgs, 0, args.length);
newArgs[args.length] = "-disableRecoveryFile";
newArgs[args.length + 1] = "-disableCache";
final WDALImpl servantDelegate = new WDALImpl(newArgs, orb, xmlCDBPOA, m_logger);
final Servant wdalImplServant = new WJDALPOATie(servantDelegate);
// WDALImpl wdalImplServant = new WDALImpl(args, orb, xmlCDBPOA, m_logger);
xmlCDBPOA.activate_object_with_id(new byte[] { 'x', 'm', 'l', 'C', 'D', 'B' }, wdalImplServant);
org.omg.CORBA.Object ref = xmlCDBPOA.servant_to_reference(wdalImplServant);
final JDAL xmlCDB_ = JDALHelper.narrow(ref);
// -----
// get set of BACI property attributes (non-extras)
String[] baciPropertyAttributes = DOMJavaClassIntrospector.getAccessibleFields(new BACIPropertyType(), true);
Set<String> baciPropertyAttributesSet = new HashSet<String>();
for (String attribute : baciPropertyAttributes) {
baciPropertyAttributesSet.add(attribute);
}
XSDElementTypeResolver xsdElementTypeResolver = new XSDElementTypeResolver(m_root, m_logger);
Set<String> nonControlDeviceSet = new TreeSet<String>();
Set<String> characteristicsDeviceSet = new TreeSet<String>();
Set<String> processedComponentTypes = new HashSet<String>();
// -----
CDBAccess cdbAccess = new CDBAccess(orb, m_logger);
cdbAccess.setDAL(xmlCDB_);
try {
hibernateUtil.beginTransaction();
Session session = hibernateUtil.getSession();
schemaResourceResolverLoader.setSession(session);
// check if configuration already exists
config = (Configuration) session.createCriteria(Configuration.class).add(Restrictions.eq("configurationName", configName)).uniqueResult();
if (config != null) {
m_logger.warning("Configuration with name '" + configName + "' already exists. Skipping loading XML stage.");
return false;
}
// create configuration
config = new Configuration();
config.setConfigurationName(configName);
config.setFullName(configName);
config.setActive(true);
config.setCreationTime(Calendar.getInstance().getTime());
config.setDescription("Imported from CDB by HibernateWDAL");
session.persist(config);
configId = config.getConfigurationId();
// plugin importPrologue()
if (plugin != null) {
try {
plugin.importPrologue(session, config, cdbAccess);
} catch (Throwable th) {
// @TODO decent exception log. Is OK to swallow th?
th.printStackTrace();
}
}
// load all schemas
loadSchemas(session);
try {
//DAO managerDAO = xmlCDB.get_DAO_Servant("MACI/Managers/Manager");
DAOProxy managerDAO = cdbAccess.createDAO("MACI/Managers/Manager");
LoggingConfig managerLoggingConfig = persistLoggingConfig(session, managerDAO, false);
Manager manager = new Manager();
manager.setConfiguration(config);
manager.setLoggingConfig(managerLoggingConfig);
manager.setStartup(managerDAO.get_string("Startup"));
manager.setServiceComponents(managerDAO.get_string("ServiceComponents"));
try {
manager.setServiceDaemons(managerDAO.get_string("ServiceDaemons"));
} catch (CDBFieldDoesNotExistEx e) {
// Optional, but has no default!
manager.setServiceDaemons("");
}
manager.setTimeout((int) managerDAO.get_double("Timeout"));
manager.setClientPingInterval((int) managerDAO.get_double("ClientPingInterval"));
manager.setAdministratorPingInterval((int) managerDAO.get_double("AdministratorPingInterval"));
manager.setContainerPingInterval((int) managerDAO.get_double("ContainerPingInterval"));
manager.setServerThreads((byte) managerDAO.get_long("ServerThreads"));
session.persist(manager);
m_logger.info("Imported Manager from XML.");
} catch (Throwable e) {
m_logger.log(Level.WARNING, "MACI/Managers/Manager record does not exist or misconfigured, using defaults.", e);
}
/*
String containers = xmlCDB.list_nodes("MACI/Containers");
StringTokenizer tokenizer = new StringTokenizer(containers);
while (tokenizer.hasMoreTokens())
{
String containerName = tokenizer.nextToken();
*/
StringTokenizer tokenizer;
String[] containerSubnodes = getSubNodes(xmlCDB_, "MACI/Containers");
for (String containerName : containerSubnodes) {
//DAO containerDAO = xmlCDB.get_DAO_Servant("MACI/Containers/"+containerName);
DAOProxy containerDAO = cdbAccess.createDAO("MACI/Containers/" + containerName);
// check if real config, otherwice skip
if (readLong(containerDAO, "LoggingConfig/minLogLevel", -1) < 0)
continue;
LoggingConfig loggingConfig = persistLoggingConfig(session, containerDAO, true);
Computer hostComputer = null;
String computerHostName = readString(containerDAO, "DeployInfo/Host", null);
if (computerHostName != null) {
hostComputer = (Computer) session.createCriteria(Computer.class).add(Restrictions.eq("networkName", computerHostName)).uniqueResult();
if (hostComputer == null) {
// NOTE: we add some dummy data as computer name, realtime flag, CPU type here
String computerName = computerHostName;
int dotPos = computerName.indexOf('.');
if (dotPos > 0)
computerName = computerName.substring(0, dotPos);
hostComputer = new Computer();
hostComputer.setName(computerName);
hostComputer.setConfiguration(config);
hostComputer.setNetworkName(computerHostName);
hostComputer.setRealTime(false);
hostComputer.setDiskless(false);
hostComputer.setProcessorType(ComputerProcessorType.UNI);
hostComputer.setPhysicalLocation(null);
session.persist(hostComputer);
}
}
final String containerPath;
int hierarchySeparatorPos = containerName.lastIndexOf('/');
if (hierarchySeparatorPos != -1) {
containerPath = containerName.substring(0, hierarchySeparatorPos);
containerName = containerName.substring(hierarchySeparatorPos + 1);
} else
// for Oracle
containerPath = "/";
Container container = new Container();
container.setContainerName(containerName);
container.setPath(containerPath);
container.setConfiguration(config);
container.setLoggingConfig(loggingConfig);
container.setComputer(hostComputer);
// cpp is default, since field is required
container.setImplLang(ImplLangEnum.valueOfForEnum(readString(containerDAO, "ImplLang", "cpp")));
container.setTypeModifiers(readString(containerDAO, "DeployInfo/TypeModifiers", null));
container.setStartOnDemand(Boolean.valueOf(readString(containerDAO, "DeployInfo/StartOnDemand", "false")));
container.setRealTime(false);
container.setRealTimeType(null);
container.setKernelModuleLocation(null);
container.setKernelModule(null);
container.setKeepAliveTime(readLong(containerDAO, "DeployInfo/KeepAliveTime", -1));
container.setServerThreads(containerDAO.get_long("ServerThreads"));
container.setManagerRetry(containerDAO.get_long("ManagerRetry"));
container.setCallTimeout((int) containerDAO.get_double("Timeout"));
container.setRecovery(Boolean.valueOf(containerDAO.get_string("Recovery")));
int pingInterval = readLong(containerDAO, "PingInterval", Integer.MIN_VALUE);
if (pingInterval != Integer.MIN_VALUE)
container.setPingInterval(pingInterval);
container.setAutoloadSharedLibs(containerDAO.get_string("Autoload"));
session.persist(container);
// convert the "Flags" string of concatenated options to ContainerStartupOption
String containerStartFlags = readString(containerDAO, "DeployInfo/Flags", null);
ContainerStartupOptionHelper containerStartupOptionHelper = new ContainerStartupOptionHelper(m_logger);
Collection<ContainerStartupOption> contOptions = containerStartupOptionHelper.convertFlagsString(container, containerStartFlags);
for (ContainerStartupOption containerStartupOption : contOptions) {
session.persist(containerStartupOption);
}
}
if (containerSubnodes.length > 0) {
m_logger.info("Imported Containers from XML.");
} else {
m_logger.info("No XML container data found.");
}
// set of all existing component names
// used to generate *, *1, *2 names, as CDB does
// NOTE: initial set is not filled with component names that are already in the DB
Set<String> existingComponentNames = new HashSet<String>();
LinkedHashSet nodes = new LinkedHashSet();
//DAO componentDAO = xmlCDB.get_DAO_Servant("MACI/Components");
DAOProxy componentDAO = null;
try {
componentDAO = cdbAccess.createDAO("MACI/Components");
// current
nodes.add("/");
String[] subnodes = getSubnodes(xmlCDB_, "MACI/Components");
if (subnodes != null)
for (int i = 0; i < subnodes.length; i++) nodes.add(subnodes[i]);
} catch (RuntimeException rte) {
m_logger.warning("Failed to read MACI/Components DAO, skipping...");
}
Iterator iter = nodes.iterator();
while (iter.hasNext()) {
String path = iter.next().toString();
String prefix;
if (path.length() == 0 || path.equals("/"))
prefix = "";
else
prefix = path + "/";
String components = (String) componentDAO.get_field_data(prefix + "_elements");
// store "original" path/prefix (it can be changed)
final String originalPath = path;
final String originalPrefix = prefix;
tokenizer = new StringTokenizer(components, ",");
while (tokenizer.hasMoreTokens()) {
// set original values
path = originalPath;
prefix = originalPrefix;
String componentName = prefix + tokenizer.nextToken();
String realComponentName = readString(componentDAO, componentName + "/Name", null);
if (realComponentName == null)
continue;
// hierarchical name fix
int hierarchySeparatorPos = realComponentName.lastIndexOf('/');
if (hierarchySeparatorPos != -1)
realComponentName = realComponentName.substring(hierarchySeparatorPos + 1);
// "/////" is the same as "/" for TMCDB, but not for DB
while (existingComponentNames.contains(prefix + realComponentName)) {
path = path + "/";
prefix = prefix + "/";
}
existingComponentNames.add(prefix + realComponentName);
int componentContainerId = -1;
Container tmpComponentContainer = null;
String containerName = readString(componentDAO, componentName + "/Container", null);
if (containerName != null && !containerName.equals("*")) {
String containerPath;
hierarchySeparatorPos = containerName.lastIndexOf('/');
if (hierarchySeparatorPos != -1) {
containerPath = containerName.substring(0, hierarchySeparatorPos);
containerName = containerName.substring(hierarchySeparatorPos + 1);
} else {
// for Oracle
containerPath = "/";
}
Container container = (Container) session.createCriteria(Container.class).add(Restrictions.eq("configuration", config)).add(Restrictions.eq("containerName", containerName)).add(Restrictions.eq("path", containerPath)).uniqueResult();
if (container != null) {
componentContainerId = container.getContainerId();
tmpComponentContainer = container;
} else {
LoggingConfig loggingConfig = new LoggingConfig();
loggingConfig.setMinLogLevelDefault((byte) 2);
loggingConfig.setMinLogLevelLocalDefault((byte) 2);
loggingConfig.setCentralizedLogger("Log");
loggingConfig.setDispatchPacketSize((byte) 10);
loggingConfig.setImmediateDispatchLevel((byte) 10);
loggingConfig.setFlushPeriodSeconds((byte) 10);
loggingConfig.setMaxLogQueueSize(1000);
loggingConfig.setMaxLogsPerSecond(-1);
session.persist(loggingConfig);
container = new Container();
container.setContainerName(containerName);
container.setPath(containerPath);
container.setConfiguration(config);
container.setLoggingConfig(loggingConfig);
container.setComputer(null);
// cpp is default, since field is required
container.setImplLang(ImplLangEnum.valueOfForEnum(readString(componentDAO, "ImplLang", "cpp")));
container.setTypeModifiers(DUMMY_CONTAINER_FLAG);
container.setRealTime(false);
container.setRealTimeType(null);
container.setKernelModuleLocation(null);
container.setKernelModule(null);
container.setKeepAliveTime(-1);
container.setServerThreads(5);
container.setManagerRetry(10);
container.setCallTimeout(2);
container.setRecovery(false);
container.setAutoloadSharedLibs(null);
session.persist(container);
componentContainerId = container.getContainerId();
tmpComponentContainer = container;
}
}
String xml = null;
boolean almaBranchDoesNotExist = componentName.startsWith("*");
boolean forceSubcomponentCheck = false;
int typeId;
String type = componentDAO.get_string(componentName + "/Type");
// pulled out for performance optimization, to avoid reading it twice in many cases
DAOProxy componentConfigurationDAO = null;
Schemas schema = null;
{
String schemaURN = null;
// check if it is a non-control device, simply check for existence of "ControlDevice" element
if (!almaBranchDoesNotExist) {
try {
// @TODO: Suppress the NOTICE log (or lower its level) which we get from the CDB code if there is no component configuration under the CDB/alma/ branch.
// NOTICE [CDB-RDB] Curl 'alma/SCHEDULING_MASTERSCHEDULER' does not exist.
componentConfigurationDAO = cdbAccess.createDAO(COMPONENT_TREE_NAME + "/" + componentName);
schemaURN = componentConfigurationDAO.get_string("xmlns");
if (!processedComponentTypes.contains(type)) {
boolean isControlDevice = !TMCDB_ACS_ONLY && xsdElementTypeResolver.doesExtend(schemaURN, "ControlDevice");
m_logger.fine(schemaURN + " does extend Control? " + isControlDevice);
if (!isControlDevice)
nonControlDeviceSet.add(type);
boolean isCharateristicsComponent = xsdElementTypeResolver.doesExtend(schemaURN, "CharacteristicComponent") || // sadly ControlDevice does not extend CharacteristicComponent XSD
(TMCDB_ACS_ONLY && xsdElementTypeResolver.doesExtend(schemaURN, "ControlDevice"));
m_logger.fine(schemaURN + " does extend CharacteristicsComponent? " + isCharateristicsComponent);
if (isCharateristicsComponent)
characteristicsDeviceSet.add(type);
processedComponentTypes.add(type);
}
} catch (Throwable th) {
almaBranchDoesNotExist = true;
// (ComponentType is filled at first occurrence of the type)
if (th.getCause() instanceof CDBRecordDoesNotExistEx) {
// does not exists, this is OK... do not complain
} else if (th instanceof CDBFieldDoesNotExistEx) {
// field does not exist, but it might have sub-components
forceSubcomponentCheck = true;
} else {
m_logger.log(AcsLogLevel.WARNING, "Failed to read component configuration: " + COMPONENT_TREE_NAME + "/" + componentName, th);
}
}
}
// get the Schema identifier for the schemaURN
schema = (Schemas) session.createCriteria(Schemas.class).add(Restrictions.eq("URN", schemaURN)).add(Restrictions.eq("configuration", config)).uniqueResult();
if (schema == null && !almaBranchDoesNotExist)
m_logger.severe("Component " + componentName + " of XSD type " + schemaURN + " has no XSD file.");
ComponentType componentType = (ComponentType) session.createCriteria(ComponentType.class).add(Restrictions.eq("IDL", type)).uniqueResult();
if (componentType == null) {
componentType = new ComponentType();
componentType.setIDL(type);
session.saveOrUpdate(componentType);
}
typeId = componentType.getComponentTypeId();
}
boolean isControlDevice = !nonControlDeviceSet.contains(type) && !almaBranchDoesNotExist;
boolean isCharateristicsDevice = characteristicsDeviceSet.contains(type);
if (!isControlDevice && !isCharateristicsDevice && xml == null && !almaBranchDoesNotExist) {
xml = getComponentXML(xmlCDB_, componentName, xml);
}
Component component = new Component();
// TODO this can be optimized!!!
component.setComponentType((ComponentType) session.get(ComponentType.class, typeId));
component.setComponentName(realComponentName);
component.setConfiguration(config);
// component.setContainerId(componentContainerId);
// TODO verify this and clean up
component.setContainer(tmpComponentContainer);
// cpp is default, since field is required
component.setImplLang(ImplLangEnum.valueOfForEnum(readString(componentDAO, componentName + "/ImplLang", "cpp")));
component.setRealTime(false);
component.setCode(componentDAO.get_string(componentName + "/Code"));
component.setPath(path);
component.setIsAutostart(Boolean.parseBoolean(componentDAO.get_string(componentName + "/Autostart")));
component.setIsDefault(Boolean.parseBoolean(componentDAO.get_string(componentName + "/Default")));
component.setIsStandaloneDefined(true);
component.setIsControl(isControlDevice);
component.setKeepAliveTime(componentDAO.get_long(componentName + "/KeepAliveTime"));
component.setMinLogLevel((byte) readLong(componentDAO, componentName + "/ComponentLogger/minLogLevel", -1));
component.setMinLogLevelLocal((byte) readLong(componentDAO, componentName + "/ComponentLogger/minLogLevelLocal", -1));
component.setXMLDoc(xml);
component.setURN(schema == null ? null : schema.getURN());
session.persist(component);
session.flush();
// try to create alma branch (if available)
if ((isControlDevice || isCharateristicsDevice) && !almaBranchDoesNotExist) {
try {
if (componentConfigurationDAO == null) {
componentConfigurationDAO = cdbAccess.createDAO(COMPONENT_TREE_NAME + "/" + componentName);
}
if (plugin != null && isControlDevice) {
plugin.controlDeviceImportEpilogue(session, config, cdbAccess, componentName, component);
}
Set<String> propertySet = new TreeSet<String>();
String[] propertyCandidates = componentConfigurationDAO.get_string_seq("_elements");
for (String propertyName : propertyCandidates) {
// check if really property
if (readString(componentConfigurationDAO, propertyName + "/format", null) != null) {
m_logger.finer("Adding property " + propertyName);
propertySet.add(propertyName);
}
}
if (propertySet.size() > 0) {
String[] properties = propertySet.toArray(new String[propertySet.size()]);
String defaultPropertyNs = componentConfigurationDAO.get_string("xmlns");
String[] propertyNs = new String[properties.length];
for (int i = 0; i < properties.length; i++) propertyNs[i] = readString(componentConfigurationDAO, properties[i] + "/xmlns", defaultPropertyNs);
ExtraDataFeatureUtil extraDataFeatureUtil = new ExtraDataFeatureUtil(m_logger);
String[] propertyTypes = xsdElementTypeResolver.getElementTypes(componentConfigurationDAO.getElementName(), propertyNs, properties);
for (int i = 0; i < properties.length; i++) {
String propertyName = properties[i];
if (propertyTypes[i] != null && propertyTypes[i].endsWith("Seq")) {
propertyTypes[i] = propertyTypes[i].substring(0, propertyTypes[i].length() - 3);
}
BACIProperty baciPropertyType = new BACIProperty();
baciPropertyType.setComponent(component);
baciPropertyType.setPropertyName(propertyName);
baciPropertyType.setDescription(nonEmptyString(componentConfigurationDAO.get_string(propertyName + "/description"), "-"));
baciPropertyType.setFormat(nonEmptyString(componentConfigurationDAO.get_string(propertyName + "/format"), "%s"));
baciPropertyType.setUnits(nonEmptyString(componentConfigurationDAO.get_string(propertyName + "/units"), "-"));
baciPropertyType.setResolution(nonEmptyString(componentConfigurationDAO.get_string(propertyName + "/resolution"), EmptyStringHandlerBACIPropertyType.EMPTY_STRING_SUBSTITUTE));
baciPropertyType.setArchive_priority(componentConfigurationDAO.get_long(propertyName + "/archive_priority"));
baciPropertyType.setArchive_min_int(componentConfigurationDAO.get_double(propertyName + "/archive_min_int"));
baciPropertyType.setArchive_max_int(componentConfigurationDAO.get_double(propertyName + "/archive_max_int"));
baciPropertyType.setArchive_suppress(Boolean.parseBoolean(componentConfigurationDAO.get_string(propertyName + "/archive_suppress")));
baciPropertyType.setArchive_mechanism(BACIPropArchMech.valueOfForEnum(nonEmptyString(componentConfigurationDAO.get_string(propertyName + "/archive_mechanism"), "monitor_collector")));
baciPropertyType.setDefault_timer_trig(componentConfigurationDAO.get_double(propertyName + "/default_timer_trig"));
baciPropertyType.setMin_timer_trig(componentConfigurationDAO.get_double(propertyName + "/min_timer_trig"));
baciPropertyType.setInitialize_devio(Boolean.parseBoolean(componentConfigurationDAO.get_string(propertyName + "/initialize_devio")));
/* P<type> */
baciPropertyType.setMin_delta_trig(readDouble(componentConfigurationDAO, propertyName + "/min_delta_trig", 0.0));
baciPropertyType.setDefault_value(nonEmptyString(componentConfigurationDAO.get_string(propertyName + "/default_value"), "-"));
baciPropertyType.setGraph_min(limitDouble(readDouble(componentConfigurationDAO, propertyName + "/graph_min", null)));
baciPropertyType.setGraph_max(limitDouble(readDouble(componentConfigurationDAO, propertyName + "/graph_max", null)));
baciPropertyType.setMin_step(readDouble(componentConfigurationDAO, propertyName + "/min_step", null));
baciPropertyType.setArchive_delta(readDouble(componentConfigurationDAO, propertyName + "/archive_delta", 0.0));
baciPropertyType.setArchive_delta_percent(readDouble(componentConfigurationDAO, propertyName + "/archive_delta_percent", null));
/* RO<type> */
baciPropertyType.setAlarm_high_on(readDouble(componentConfigurationDAO, propertyName + "/alarm_high_on", null));
baciPropertyType.setAlarm_low_on(readDouble(componentConfigurationDAO, propertyName + "/alarm_low_on", null));
baciPropertyType.setAlarm_high_off(readDouble(componentConfigurationDAO, propertyName + "/alarm_high_off", null));
baciPropertyType.setAlarm_low_off(readDouble(componentConfigurationDAO, propertyName + "/alarm_low_off", null));
baciPropertyType.setAlarm_timer_trig(readDouble(componentConfigurationDAO, propertyName + "/alarm_timer_trig", null));
/* RW<type> */
baciPropertyType.setMin_value(limitDouble(readDouble(componentConfigurationDAO, propertyName + "/min_value", null)));
baciPropertyType.setMax_value(limitDouble(readDouble(componentConfigurationDAO, propertyName + "/max_value", null)));
/* ROpattern */
baciPropertyType.setBitDescription(nonEmptyString(readString(componentConfigurationDAO, propertyName + "/bitDescription", null), EmptyStringHandlerBACIPropertyType.EMPTY_STRING_SUBSTITUTE));
baciPropertyType.setWhenSet(nonEmptyString(readString(componentConfigurationDAO, propertyName + "/whenSet", null), EmptyStringHandlerBACIPropertyType.EMPTY_STRING_SUBSTITUTE));
baciPropertyType.setWhenCleared(nonEmptyString(readString(componentConfigurationDAO, propertyName + "/whenCleared", null), EmptyStringHandlerBACIPropertyType.EMPTY_STRING_SUBSTITUTE));
/* PEnum */
baciPropertyType.setStatesDescription(nonEmptyString(readString(componentConfigurationDAO, propertyName + "/statesDescription", null), EmptyStringHandlerBACIPropertyType.EMPTY_STRING_SUBSTITUTE));
baciPropertyType.setCondition(nonEmptyString(readString(componentConfigurationDAO, propertyName + "/condition", null), EmptyStringHandlerBACIPropertyType.EMPTY_STRING_SUBSTITUTE));
baciPropertyType.setAlarm_on(nonEmptyString(readString(componentConfigurationDAO, propertyName + "/alarm_on", null), EmptyStringHandlerBACIPropertyType.EMPTY_STRING_SUBSTITUTE));
baciPropertyType.setAlarm_off(nonEmptyString(readString(componentConfigurationDAO, propertyName + "/alarm_off", null), EmptyStringHandlerBACIPropertyType.EMPTY_STRING_SUBSTITUTE));
/* alarms */
baciPropertyType.setAlarm_fault_family(nonEmptyString(readString(componentConfigurationDAO, propertyName + "/alarm_fault_family", null), EmptyStringHandlerBACIPropertyType.EMPTY_STRING_SUBSTITUTE));
baciPropertyType.setAlarm_fault_member(nonEmptyString(readString(componentConfigurationDAO, propertyName + "/alarm_fault_member", null), EmptyStringHandlerBACIPropertyType.EMPTY_STRING_SUBSTITUTE));
int level = readLong(componentConfigurationDAO, propertyName + "/alarm_level", Integer.MIN_VALUE);
if (level != Integer.MIN_VALUE)
baciPropertyType.setAlarm_level(level);
baciPropertyType.setData(extraDataFeatureUtil.getExtraDataMap(componentConfigurationDAO, propertyName, baciPropertyAttributesSet, ExtraDataFeatureUtil.EMPTY_SET));
session.persist(baciPropertyType);
}
// add non-property elements
// this is handled by HW plugin
propertySet.add("Address");
component.setXMLDoc(extraDataFeatureUtil.getExtraDataMap(componentConfigurationDAO, null, ExtraDataFeatureUtil.EMPTY_SET, propertySet));
session.update(component);
} else {
// no properties, add entire XML although it is a control device
component.setXMLDoc(xml == null ? getComponentXML(xmlCDB_, componentName, xml) : xml);
session.update(component);
}
// from remote, since DAO will compact it
if (!almaBranchDoesNotExist || forceSubcomponentCheck) {
String componentNodes = xmlCDB_.list_nodes(COMPONENT_TREE_NAME + "/" + componentName);
if (componentNodes != null) {
StringTokenizer tokenizer2 = new StringTokenizer(componentNodes);
while (tokenizer2.hasMoreTokens()) propertySet.add(tokenizer2.nextToken());
}
}
} catch (RuntimeException rte) {
// ignore components with no configuration; this is very ugly wat of doing it...
if (rte.getMessage() != null && rte.getMessage().startsWith("Failed to obtain")) {
// noop (there is no configuration for component)
} else
rte.printStackTrace();
}
}
}
}
if (nodes.size() > 0) {
// if the preceding while loop actually did something...
m_logger.info("Imported Components from XML.");
}
//
// Channels configurations
//
String[] channelSubnodes = getSubNodes(xmlCDB_, "MACI/Channels");
for (String channelName : channelSubnodes) {
//DAO channelDAO = xmlCDB.get_DAO_Servant("MACI/Channels/"+channelName);
DAOProxy channelDAO = cdbAccess.createDAO("MACI/Channels/" + channelName);
final String channelPath;
final String channelShortName;
int hierarchySeparatorPos = channelName.lastIndexOf('/');
if (hierarchySeparatorPos != -1) {
channelPath = channelName.substring(0, hierarchySeparatorPos);
channelShortName = channelName.substring(hierarchySeparatorPos + 1);
} else {
// for Oracle
channelPath = "/";
channelShortName = channelName;
}
EventChannel eventChannel = new EventChannel();
eventChannel.setConfiguration(config);
eventChannel.setName(channelShortName);
eventChannel.setPath(channelPath);
eventChannel.setIntegrationLogs(Boolean.valueOf(readString(channelDAO, "IntegrationLogs", "false")));
eventChannel.setMaxQueueLength(readLong(channelDAO, "MaxQueueLength", 0));
eventChannel.setMaxConsumers(readLong(channelDAO, "MaxConsumers", 0));
eventChannel.setMaxSuppliers(readLong(channelDAO, "MaxSuppliers", 0));
eventChannel.setRejectNewEvents(Boolean.valueOf(readString(channelDAO, "RejectNewEvents", "false")));
eventChannel.setDiscardPolicy(EventChannelDiscardPolicy.valueOfForEnum(readString(channelDAO, "DiscardPolicy", "AnyOrder")));
eventChannel.setEventReliability(EventChannelEventReliability.valueOfForEnum(readString(channelDAO, "EventReliability", "BestEffort")));
eventChannel.setConnectionReliability(EventChannelConReliability.valueOfForEnum(readString(channelDAO, "ConnectionReliability", "BestEffort")));
eventChannel.setPriority((short) readLong(channelDAO, "Priority", 0));
eventChannel.setTimeout(readLong(channelDAO, "Timeout", 0));
eventChannel.setOrderPolicy(EventChannelOrderPolicy.valueOfForEnum(readString(channelDAO, "OrderPolicy", "AnyOrder")));
eventChannel.setStartTimeSupported(Boolean.valueOf(readString(channelDAO, "StartTimeSupported", "false")));
eventChannel.setStopTimeSupported(Boolean.valueOf(readString(channelDAO, "StopTimeSupported", "false")));
eventChannel.setMaxEventsPerConsumer(readLong(channelDAO, "MaxEventsPerConsumer", 0));
session.persist(eventChannel);
Set<Event> eventSet = eventChannel.getEvents();
String[] events = readStringSeq(channelDAO, "Events", null);
if (events != null) {
for (String eventName : events) {
Event event = new Event();
event.setName(eventName);
event.setEventChannel(eventChannel);
event.setMaxProcessTime(readDouble(channelDAO, eventName + "/MaxProcessTime", 2.0));
eventSet.add(event);
session.persist(event);
}
}
}
try {
DAOProxy notificationServiceMappingDAO = cdbAccess.createDAO("MACI/Channels/NotificationServiceMapping");
String defaultNotSrv = notificationServiceMappingDAO.get_string("DefaultNotificationService");
NotificationServiceMapping mappings = new NotificationServiceMapping();
mappings.setConfiguration(config);
mappings.setDefaultNotificationService(defaultNotSrv);
session.persist(mappings);
String[] domains = readStringSeq(notificationServiceMappingDAO, "Domains", null);
if (domains != null) {
for (String domain : domains) {
String name = notificationServiceMappingDAO.get_string("Domains/" + domain + "/Name");
String notSrv = notificationServiceMappingDAO.get_string("Domains/" + domain + "/NotificationService");
DomainsMapping domainsMapping = new DomainsMapping();
domainsMapping.setNotificationServiceMapping(mappings);
domainsMapping.setName(name);
domainsMapping.setNotificationService(notSrv);
mappings.getDomainsMappings().add(domainsMapping);
session.persist(domainsMapping);
}
}
String[] channels = readStringSeq(notificationServiceMappingDAO, "Channels_", null);
if (channels != null) {
for (String channel : channels) {
String name = notificationServiceMappingDAO.get_string("Channels_/" + channel + "/Name");
String notSrv = notificationServiceMappingDAO.get_string("Channels_/" + channel + "/NotificationService");
ChannelMapping channelsMapping = new ChannelMapping();
channelsMapping.setNotificationServiceMapping(mappings);
channelsMapping.setName(name);
channelsMapping.setNotificationService(notSrv);
mappings.getChannelMappings().add(channelsMapping);
session.persist(channelsMapping);
}
}
} catch (RuntimeException re) {
// no mappings
}
m_logger.info("Imported Notification Channels from XML.");
// plugin importEpilogue()
if (plugin != null) {
try {
plugin.importEpilogue(session, config, cdbAccess);
} catch (Throwable th) {
// @TODO: Decent exception log.
th.printStackTrace();
}
}
hibernateUtil.commitTransaction();
m_logger.info("Configuration from XML CDB loaded.");
} catch (CDBFieldDoesNotExistEx ex) {
throw AcsJCDBFieldDoesNotExistEx.fromCDBFieldDoesNotExistEx(ex);
} catch (WrongCDBDataTypeEx ex) {
throw AcsJWrongCDBDataTypeEx.fromWrongCDBDataTypeEx(ex);
} catch (Throwable th) {
throw new RuntimeException("Failed to fill-in the DB from CDB.", th);
} finally {
hibernateUtil.closeSession();
cdbAccess.destroy();
xmlCDB_._release();
servantDelegate.shutdownEmbeddedWDALImpl();
// destroy POA
xmlCDBPOA.destroy(true, false);
}
return true;
} catch (Throwable th) {
m_logger.log(Level.SEVERE, "Failed to load XML CDB, exiting...", th);
return false;
} finally {
loadInProgress.set(false);
}
}
use of alma.cdbErrType.CDBRecordDoesNotExistEx in project ACS by ACS-Community.
the class HibernateWDALImpl method getComponentXML.
/**
* @param xmlCDB
* @param componentName
* @param xml
* @return XML string, or null, but not an empty string.
* @throws CDBXMLErrorEx
* @throws DOMException
* @throws RuntimeException
*/
private String getComponentXML(final JDAL xmlCDB, String componentName, String xml) throws CDBXMLErrorEx, DOMException, RuntimeException {
// try to create component, i.e. alma, branch (if available)
try {
// hierarchical check..
String nodes = xmlCDB.list_nodes(COMPONENT_TREE_NAME + "/" + componentName);
boolean isHierarhicalWithXML = (nodes != null) && (nodes.trim().length() > 0);
if (isHierarhicalWithXML) {
try {
String nameOnly = componentName;
int pos = nameOnly.lastIndexOf('/');
if (pos > 0)
nameOnly = nameOnly.substring(pos + 1);
// reach for file
File xmlFile = new File(m_root + File.separatorChar + COMPONENT_TREE_NAME + File.separatorChar + componentName + File.separatorChar + nameOnly + ".xml");
//System.out.println(xmlFile.getAbsolutePath() + ", " + xmlFile.exists());
final BufferedReader reader = new BufferedReader(new FileReader(xmlFile));
final StringBuffer file = new StringBuffer();
String line;
while ((line = reader.readLine()) != null) file.append(line).append('\n');
xml = file.toString();
} catch (Throwable th) {
throw new RuntimeException("Failed to read XML for component " + componentName);
}
} else {
xml = xmlCDB.get_DAO(COMPONENT_TREE_NAME + "/" + componentName);
}
} catch (CDBRecordDoesNotExistEx rdne) {
// noop, no data
}
// Oracle XMLTYPE attributes don't like empty XML, thus we convert it to null
if (xml != null && xml.trim().isEmpty()) {
xml = null;
}
return xml;
}
Aggregations