Changeset 383


Ignore:
Timestamp:
04/26/2010 03:07:26 AM (11 years ago)
Author:
pedro.cuba
Message:

Made changes so that cmionMain could be supported in Android:
-Added method to open configuration files in CompetencyManager? and CompetencyLibrary?.
-Changed Migration and Synchronizer to support identical XML handling in Android.

Location:
libs/cmion/cmionMain/src/cmion
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed
  • libs/cmion/cmionMain/src/cmion/level2/CompetencyLibrary.java

    r296 r383  
    3636 
    3737import java.io.File; 
     38import java.io.FileInputStream; 
     39import java.io.InputStream; 
    3840import java.lang.reflect.Constructor; 
    3941import java.util.ArrayList; 
     
    119121                }        
    120122        } 
    121  
    122         /** load the competency library configuration file that specifies which competencies to load*/ 
    123         private void loadConfigurationFile(String competencyLibraryFile) throws Exception 
    124         { 
     123         
     124        protected InputStream openConfigurationFile(String competencyLibraryFile) throws Exception{ 
    125125                File configFile = new File(competencyLibraryFile); 
    126126                if (!configFile.exists())  
    127127                        throw new Exception("Could not locate competency library configuration file " + competencyLibraryFile); 
     128                return new FileInputStream(configFile); 
     129        } 
     130 
     131        /** load the competency library configuration file that specifies which competencies to load*/ 
     132        private void loadConfigurationFile(String competencyLibraryFile) throws Exception 
     133        { 
     134                InputStream inStream = openConfigurationFile(competencyLibraryFile); 
    128135                 
    129136                // parse the file to a dom document 
    130137                DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance(); 
    131138                DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder(); 
    132                 Document doc = docBuilder.parse (configFile); 
     139                Document doc = docBuilder.parse (inStream); 
    133140 
    134141                // normalize text representation 
  • libs/cmion/cmionMain/src/cmion/level2/competencies/Migration.java

    r379 r383  
    4848import cmion.level2.migration.Synchronize; 
    4949import cmion.level2.migration.Synchronizer; 
     50import cmion.level2.migration.SynchronizerImpl; 
    5051 
    5152 
     
    122123         * access to resources.  
    123124         *  
    124          * @return InputStream for the conifguration file of the migration competency. 
     125         * @return InputStream for the configuration file of the migration competency. 
    125126         */ 
    126127        protected InputStream openConfigFile(String configFile) { 
     
    161162                //Set up the synchronization element 
    162163                try { 
    163                         this.sync = new Synchronizer(listenPort); 
     164                        this.sync = getNewSynchronizer(listenPort); 
    164165                } catch (IOException e) { 
    165166                        System.out.println("Could not create migration listening socket."); 
     
    173174                 
    174175                available = true; 
     176        } 
     177         
     178        protected Synchronizer getNewSynchronizer(int listenPort) throws IOException, ParserConfigurationException{ 
     179                return new SynchronizerImpl(listenPort); 
    175180        } 
    176181 
     
    411416                        SynchronizationStart synchStart = (SynchronizationStart) evt; 
    412417                         
     418                        Element syncElement = migrationDocument.createElement(Synchronizer.SYNC_TAG); 
    413419                        Element migration = migrationDocument.createElement("migration"); 
     420                        migrationDocument.appendChild(syncElement); 
     421                        syncElement.appendChild(migration); 
     422 
    414423                        for (Element element : migrationElements) { 
    415                                 Node adoptedNode = migrationDocument.adoptNode(element); 
    416                                 migration.appendChild(adoptedNode); 
    417                         } 
    418                          
    419                         sync.packMessage(migration); 
     424                                migration.appendChild(element); 
     425                        } 
     426 
     427                        sync.replaceMessage(migrationDocument); 
     428 
    420429                } 
    421430        } 
     
    473482                         
    474483                        if (added.getItem().equals(Migration.this)){ 
    475                                 System.out.println("Adding Synchronizer to Simulation.\n"+sync); 
    476                                 System.out.println(added.getItem() +" - "+ added.getElement()); 
    477                                  
    478484                                getSimulation().getElements().add(sync); 
    479485                        } 
     
    492498                         
    493499                        if (removed.getItem().equals(Migration.this)){ 
    494                                 System.out.println("Removing Synchronizer of Simulation."); 
    495                                  
    496500                                getSimulation().getElements().remove(sync); 
    497501                        } 
  • libs/cmion/cmionMain/src/cmion/level2/migration/Synchronizer.java

    r366 r383  
    1212import javax.xml.parsers.DocumentBuilderFactory; 
    1313import javax.xml.parsers.ParserConfigurationException; 
    14 import javax.xml.transform.OutputKeys; 
    15 import javax.xml.transform.Transformer; 
    16 import javax.xml.transform.TransformerConfigurationException; 
    17 import javax.xml.transform.TransformerException; 
    18 import javax.xml.transform.TransformerFactory; 
    19 import javax.xml.transform.TransformerFactoryConfigurationError; 
    20 import javax.xml.transform.dom.DOMSource; 
    21 import javax.xml.transform.stream.StreamResult; 
    22  
    23 import org.w3c.dom.DOMException; 
     14 
    2415import org.w3c.dom.Document; 
    2516import org.w3c.dom.Node; 
     
    3728import ion.Meta.TypeSet; 
    3829 
    39 public class Synchronizer extends Element { 
     30public abstract class Synchronizer extends Element { 
    4031         
    4132        public final static String SYNC_TAG = "synchronize"; 
     
    7162         
    7263        public void packMessage(org.w3c.dom.Element message){ 
    73                 try { 
    74                         fullMessage.adoptNode(message); 
    75                         fullMessage.getElementsByTagName(SYNC_TAG).item(0).appendChild(message); 
    76                 } catch (DOMException e) { 
    77                         fullMessage.importNode(message, true); 
    78                 } 
     64                Node importedNode = fullMessage.importNode(message, true); 
     65                fullMessage.getElementsByTagName(SYNC_TAG).item(0).appendChild(importedNode); 
     66        } 
     67         
     68        public void replaceMessage(Document doc){ 
     69                fullMessage = doc; 
    7970        } 
    8071         
     
    10899        } 
    109100         
    110         private void writeXML(Document doc, OutputStream stream){ 
    111                 Transformer transformer = null; 
    112                 try { 
    113                         transformer = TransformerFactory.newInstance().newTransformer(); 
    114                 } catch (TransformerConfigurationException e) { 
    115                         e.printStackTrace(); 
    116                 } catch (TransformerFactoryConfigurationError e) { 
    117                         e.printStackTrace(); 
    118                 } 
    119                  
    120                 transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8"); 
    121                 transformer.setOutputProperty(OutputKeys.INDENT, "yes"); 
    122                  
    123                 try { 
    124                         transformer.transform(new DOMSource(doc), new StreamResult(stream)); 
    125                 } catch (TransformerException e) { 
    126                         e.printStackTrace(); 
    127                 } 
    128         } 
     101        protected abstract void writeXML(Document doc, OutputStream stream); 
    129102         
    130103        private void sendXMLMessage(Document message, Socket socket) throws IOException{ 
     
    258231                                org.w3c.dom.Element root = fullMessage.createElement(SYNC_TAG); 
    259232                                fullMessage.appendChild(root); 
     233                                 
     234                                //TODO Check why the order of next lines matters. In ION it shouldn't matter. 
     235                                raise(new SynchronizationStart(request.host, request.port, fullMessage)); 
    260236                                schedule(new SendMessage(request.host, request.port)); 
    261                                 raise(new SynchronizationStart(request.host, request.port, fullMessage)); 
    262237                        } 
    263238                } 
     
    285260                                try { 
    286261                                        System.out.println("Sending Message"); 
     262                                         
    287263                                        sendXMLMessage(fullMessage, socket); 
    288264                                } catch (IOException e) { 
     
    320296                                doc.appendChild(root); 
    321297                                 
    322                                 Node messageNode = doc.adoptNode(request.message.getDocumentElement()); 
     298                                Node messageNode = doc.importNode(request.message.getDocumentElement(), true); 
    323299                                root.appendChild(messageNode); 
    324300                                 
  • libs/cmion/cmionMain/src/cmion/level3/CompetencyManager.java

    r248 r383  
    3838 
    3939import java.io.File; 
     40import java.io.FileInputStream; 
     41import java.io.InputStream; 
    4042import java.util.ArrayList; 
    4143import java.util.HashMap; 
     
    4446import javax.xml.parsers.DocumentBuilderFactory; 
    4547 
    46  
    4748import org.w3c.dom.Document; 
    4849import org.w3c.dom.NodeList; 
    4950 
     51import cmion.architecture.CmionComponent; 
    5052import cmion.architecture.IArchitecture; 
    51 import cmion.architecture.CmionComponent; 
    5253import cmion.level2.CompetencyExecutionPlan; 
    5354import cmion.level2.EventCompetencyExecutionPlanFailed; 
     
    163164        } 
    164165         
     166        protected InputStream openRulesFile(String competencyManagerRulesFileName) throws Exception{ 
     167                File compManagerRulesFile = new File(competencyManagerRulesFileName); 
     168 
     169                // check if file exists 
     170                if (! compManagerRulesFile.exists()) throw new Exception("cannot locate competency manager rules file " + competencyManagerRulesFileName ); 
     171                 
     172                return new FileInputStream(compManagerRulesFile); 
     173        } 
     174         
    165175        /** parse the xml file that contains the competency manager rules */ 
    166176        private synchronized void loadRules(String competencyManagerRulesFileName) throws Exception 
    167177        { 
    168                 File compManagerRulesFile = new File(competencyManagerRulesFileName); 
    169  
    170                 // check if file exists 
    171                 if (! compManagerRulesFile.exists()) throw new Exception("cannot locate competency manager rules file " + competencyManagerRulesFileName ); 
     178                InputStream inStream = openRulesFile(competencyManagerRulesFileName); 
    172179                         
    173180                // parse the file to a dom document 
    174181                DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance(); 
    175182                DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder(); 
    176                 Document doc = docBuilder.parse (compManagerRulesFile); 
     183                Document doc = docBuilder.parse (inStream); 
    177184 
    178185                // normalize text representation 
Note: See TracChangeset for help on using the changeset viewer.