Example 1 with JDAL
use of com.cosylab.CDB.JDAL in project ACS by ACS-Community.
the class ClearCache method main.
public static void main(String[] args) {
Logger m_logger = ClientLogManager.getAcsLogManager().getLoggerForApplication("cdbjDALClearCache", false);
try {
String curl = null;
String strIOR = null;
if (args.length >= 1 && !args[0].equals("-d")) {
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("-h")) {
System.out.println("Usage: cmd [curl] [-d ior -h]");
System.out.println("if curl is not set, is invoked for all curls");
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);
JDAL dal = JDALHelper.narrow(orb.string_to_object(strIOR));
if (curl != null) {
dal.clear_cache(curl);
m_logger.log(AcsLogLevel.INFO, "Cleared CDB cache for curl=" + curl);
} else {
dal.clear_cache_all();
m_logger.log(AcsLogLevel.INFO, "Cleared CDB cache for all curls.");
}
} catch (Exception e) {
m_logger.log(AcsLogLevel.NOTICE, "Failed to clear the CDB cache:", e);
}
}Example 2 with JDAL
use of com.cosylab.CDB.JDAL in project ACS by ACS-Community.
the class FactoryTest method clearDalCache.
/**
* Clear the cache of the DAL
* @param contSvcs ContainerServices
* @throws Exception
*/
private void clearDalCache(ContainerServices contSvcs) throws Exception {
DAL dal = contSvcs.getCDB();
jdal = JDALHelper.narrow(dal);
if (jdal == null) {
throw new Exception("Error narrowing the DAL");
}
jdal.clear_cache_all();
}Example 3 with JDAL
use of com.cosylab.CDB.JDAL 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);
}
}
Also used :
EventChannelDiscardPolicy(alma.acs.tmcdb.EventChannelDiscardPolicy)
EventChannelOrderPolicy(alma.acs.tmcdb.EventChannelOrderPolicy)
LinkedHashSet(java.util.LinkedHashSet)
Configuration(alma.acs.tmcdb.Configuration)
Manager(alma.acs.tmcdb.Manager)
ClientLogManager(alma.acs.logging.ClientLogManager)
Servant(org.omg.PortableServer.Servant)
ExtraDataFeatureUtil(com.cosylab.cdb.jdal.hibernate.ExtraDataFeatureUtil)
Container(alma.acs.tmcdb.Container)
AcsJCDBFieldDoesNotExistEx(alma.cdbErrType.wrappers.AcsJCDBFieldDoesNotExistEx)
CDBFieldDoesNotExistEx(alma.cdbErrType.CDBFieldDoesNotExistEx)
TreeSet(java.util.TreeSet)
Computer(alma.acs.tmcdb.Computer)
BACIProperty(alma.acs.tmcdb.BACIProperty)
NotificationServiceMapping(alma.acs.tmcdb.NotificationServiceMapping)
AcsJWrongCDBDataTypeEx(alma.cdbErrType.wrappers.AcsJWrongCDBDataTypeEx)
WrongCDBDataTypeEx(alma.cdbErrType.WrongCDBDataTypeEx)
LinkedHashSet(java.util.LinkedHashSet)
HashSet(java.util.HashSet)
DAOPOA(com.cosylab.CDB.DAOPOA)
WJDALPOA(com.cosylab.CDB.WJDALPOA)
WDAOPOA(com.cosylab.CDB.WDAOPOA)
POA(org.omg.PortableServer.POA)
DAOProxy(com.cosylab.cdb.client.DAOProxy)
Schemas(alma.acs.tmcdb.Schemas)
ContainerStartupOption(alma.acs.tmcdb.ContainerStartupOption)
JDAL(com.cosylab.CDB.JDAL)
EmptyStringHandlerBACIPropertyType(alma.TMCDB.baci.EmptyStringHandlerBACIPropertyType)
BACIPropertyType(alma.TMCDB.baci.BACIPropertyType)
AcsJCDBRecordDoesNotExistEx(alma.cdbErrType.wrappers.AcsJCDBRecordDoesNotExistEx)
CDBRecordDoesNotExistEx(alma.cdbErrType.CDBRecordDoesNotExistEx)
EventChannel(alma.acs.tmcdb.EventChannel)
Iterator(java.util.Iterator)
Component(alma.acs.tmcdb.Component)
ContainerStartupOptionHelper(alma.acs.tmcdb.logic.ContainerStartupOptionHelper)
ComponentType(alma.acs.tmcdb.ComponentType)
CDBAccess(com.cosylab.cdb.client.CDBAccess)
ChannelMapping(alma.acs.tmcdb.ChannelMapping)
WJDALPOATie(com.cosylab.CDB.WJDALPOATie)
DomainsMapping(alma.acs.tmcdb.DomainsMapping)
StringTokenizer(java.util.StringTokenizer)
LoggingConfig(alma.acs.tmcdb.LoggingConfig)
Event(alma.acs.tmcdb.Event)
Session(org.hibernate.Session)
Aggregations
JDAL (com.cosylab.CDB.JDAL)3
BACIPropertyType (alma.TMCDB.baci.BACIPropertyType)1
EmptyStringHandlerBACIPropertyType (alma.TMCDB.baci.EmptyStringHandlerBACIPropertyType)1
ClientLogManager (alma.acs.logging.ClientLogManager)1
BACIProperty (alma.acs.tmcdb.BACIProperty)1
ChannelMapping (alma.acs.tmcdb.ChannelMapping)1
Component (alma.acs.tmcdb.Component)1
ComponentType (alma.acs.tmcdb.ComponentType)1
Computer (alma.acs.tmcdb.Computer)1
Configuration (alma.acs.tmcdb.Configuration)1
Container (alma.acs.tmcdb.Container)1
ContainerStartupOption (alma.acs.tmcdb.ContainerStartupOption)1
DomainsMapping (alma.acs.tmcdb.DomainsMapping)1
Event (alma.acs.tmcdb.Event)1
EventChannel (alma.acs.tmcdb.EventChannel)1
EventChannelDiscardPolicy (alma.acs.tmcdb.EventChannelDiscardPolicy)1
EventChannelOrderPolicy (alma.acs.tmcdb.EventChannelOrderPolicy)1
LoggingConfig (alma.acs.tmcdb.LoggingConfig)1
Manager (alma.acs.tmcdb.Manager)1
NotificationServiceMapping (alma.acs.tmcdb.NotificationServiceMapping)1
