Examples with Container alma.acs.tmcdb.Container used on opensource projects

Example 6 with Container

use of alma.acs.tmcdb.Container 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);
    }
}