Changeset 7816


Ignore:
Timestamp:
14/01/11 15:23:47 (9 years ago)
Author:
mnagni
Message:

many major changes

Location:
mauRepo/newmoon
Files:
7 added
8 edited
5 moved

Legend:

Unmodified
Added
Removed
  • mauRepo/newmoon

    • Property svn:ignore set to
      .settings

      target

      .project

      .checkstyle

      .classpath
  • mauRepo/newmoon/pom.xml

    r7815 r7816  
    22        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 
    33        <modelVersion>4.0.0</modelVersion> 
    4         <groupId>ndg.service</groupId> 
     4        <groupId>ndg.services</groupId> 
    55        <artifactId>newmoon</artifactId> 
    66        <version>0.0.1-SNAPSHOT</version> 
     
    7272                <dependency> 
    7373                        <groupId>org.slf4j</groupId> 
    74                         <artifactId>slf4j-log4j12</artifactId> 
    75                         <version>1.5.3</version> 
     74                        <artifactId>slf4j-api</artifactId> 
     75                        <version>1.6.1</version> 
     76                </dependency> 
     77                <dependency> 
     78                        <groupId>org.slf4j</groupId> 
     79                        <artifactId>slf4j-simple</artifactId> 
     80                        <version>1.6.1</version> 
    7681                </dependency> 
    7782                <dependency> 
     
    120125                        <version>3.2.1</version> 
    121126                </dependency> 
    122                 <dependency> 
    123                         <groupId>commons-logging</groupId> 
    124                         <artifactId>commons-logging</artifactId> 
    125                         <version>1.1.1</version> 
    126                 </dependency> 
     127                <!-- 
     128                        <dependency> <groupId>commons-logging</groupId> 
     129                        <artifactId>commons-logging</artifactId> <version>1.1.1</version> 
     130                        </dependency> 
     131                --> 
    127132                <dependency> 
    128133                        <groupId>commons-io</groupId> 
     
    171176                        <artifactId>newmoonReport</artifactId> 
    172177                        <version>0.0.1-SNAPSHOT</version> 
     178                </dependency> 
     179 
     180                <dependency> 
     181                        <groupId>junit</groupId> 
     182                        <artifactId>junit</artifactId> 
     183                        <version>4.8.2</version> 
     184                        <scope>test</scope> 
    173185                </dependency> 
    174186        </dependencies> 
     
    185197                        </plugin> 
    186198                </plugins> 
     199                <resources> 
     200                        <resource> 
     201                                <directory>src/main/resources</directory> 
     202                                <includes> 
     203                                        <include>**/*</include> 
     204                                </includes> 
     205                        </resource> 
     206                        <resource> 
     207                                <directory>src/test/resources</directory> 
     208                                <includes> 
     209                                        <include>**/*</include> 
     210                                </includes> 
     211                        </resource> 
     212                </resources> 
    187213        </build> 
    188214 
  • mauRepo/newmoon/src/main/java/ndg/services/newmoon/ConformanceTestReportManager.java

    r7815 r7816  
    3030                                                .getMessage().size() > 0) ? appender 
    3131                                                .appendWithSeparators(res.getMessages().getMessage(), " - ").toString() : ""; 
    32                                 ret.add(new ReportError(res.getFailed(), msgs)); 
     32                                ret.add(new ReportError("Test num. " + res.getTest().getNumber(), res.getFailed(), msgs)); 
    3333                        } 
    3434                } 
  • mauRepo/newmoon/src/main/java/ndg/services/newmoon/DBManager.java

    r7815 r7816  
    2525public class DBManager { 
    2626 
     27        private static boolean running = false; 
     28         
     29        private final static DBManager instance = new DBManager(); 
     30         
    2731        public static final String ROOT_COLLECTION_PATH = "xmldb:exist:///db"; 
    2832        private static Collection rootCollection = null; 
     
    7074        private static final Logger LOG = LoggerFactory.getLogger(DBManager.class); 
    7175         
    72         public static void initDB(Collection col) throws XMLDBException { 
    73                 for (NewmoonManager.MODULES_DEF_COLLECTION def_coll : NewmoonManager.MODULES_DEF_COLLECTION.values()) { 
    74                         createCollection(col, def_coll.getCollectionName()); 
    75                 } 
    76         } 
     76        /** Hides the default constructor */ 
     77        private DBManager(){}; 
     78         
     79        public static DBManager getInstance() { 
     80                return instance; 
     81        } 
     82         
     83        public static boolean isRunning() { 
     84                return running; 
     85        } 
     86         
     87 
    7788         
    7889        /** 
     
    8697         *             if there is an error creating the collection. 
    8798         */ 
    88         public static Collection createCollection(Collection collection, String newCollection) throws XMLDBException { 
    89                 collection = collection == null ? DBManager.getRootCollection() : collection; 
     99        public Collection createCollection(Collection collection, String newCollection) throws XMLDBException { 
     100                collection = collection == null ? getRootCollection() : collection; 
    90101                CollectionManagementService mgtService = (CollectionManagementService) collection.getService( 
    91102                                COLLECTION_MGMT_SERVICE_NAME, COLLECTION_MGMT_SERVICE_VERSION); 
     
    95106        } 
    96107         
    97         public static Resource getResource(Collection collection, String resourceID) throws XMLDBException { 
    98                 collection = collection == null ? DBManager.getRootCollection() : collection; 
     108        public Resource getResource(Collection collection, String resourceID) throws XMLDBException { 
     109                collection = collection == null ? getRootCollection() : collection; 
    99110                return collection.getResource(resourceID); 
    100111        } 
    101112         
    102         public static String[] getCollectionResourcesList(String parentCollection, String collectionName) throws XMLDBException { 
     113        public String[] getCollectionResourcesList(String parentCollection, String collectionName) throws XMLDBException { 
    103114                String[] ret = null;  
    104115                Collection collection = getCollection(parentCollection, collectionName); 
     
    109120        } 
    110121         
    111         public static String[] getCollectionResourcesList(Collection collection) throws XMLDBException { 
    112                 collection = collection == null ? DBManager.getRootCollection() : collection; 
     122        public String[] getCollectionResourcesList(Collection collection) throws XMLDBException { 
     123                collection = collection == null ? getRootCollection() : collection; 
    113124                return collection.listResources(); 
    114125        } 
    115126         
    116         public static Collection getCollection(String parentCollection, String collectionName) throws XMLDBException { 
     127        public Collection getCollection(String parentCollection, String collectionName) throws XMLDBException { 
    117128                Collection parent = getCollection(parentCollection, "admin", ""); 
    118129                String[] children = collectionName.split("/"); 
     
    127138        } 
    128139         
    129         private static Collection getCollection(String collectionName, String user, String pwd) throws XMLDBException { 
     140        private Collection getCollection(String collectionName, String user, String pwd) throws XMLDBException { 
    130141                collectionName = StringUtils.isBlank(collectionName) ? ROOT_COLLECTION_PATH : collectionName; 
    131142                return DatabaseManager.getCollection(collectionName, user, pwd); 
    132143        } 
    133144         
    134         public static void addXMLResource(Collection collection, String resourceId, File file) throws FileNotFoundException, 
     145        public void addXMLResource(Collection collection, String resourceId, File file) throws FileNotFoundException, 
    135146        XMLDBException, IOException { 
    136147                addXMLResource(collection, resourceId, IOUtils.toString(new FileReader(file))); 
    137148        } 
    138149         
    139         public static void addXMLResource(Collection collection, String resourceId, String resourceXML) throws FileNotFoundException, 
     150        public void addXMLResource(Collection collection, String resourceId, String resourceXML) throws FileNotFoundException, 
    140151        XMLDBException, IOException { 
    141152                XMLResource resource = (XMLResource) collection.createResource(resourceId, "XMLResource"); 
     
    143154        }        
    144155         
    145         public static void addBinaryResource(Collection collection, String resourceId, File file, String mimeType) throws FileNotFoundException, 
     156        public void addBinaryResource(Collection collection, String resourceId, File file, String mimeType) throws FileNotFoundException, 
    146157        XMLDBException, IOException { 
    147158                addBinaryResource(collection, resourceId, IOUtils.toString(new FileReader(file)), mimeType); 
    148159        } 
    149160         
    150         public static void addBinaryResource(Collection collection, String resourceId, String resourceXML, String mimeType) throws FileNotFoundException, 
     161        public void addBinaryResource(Collection collection, String resourceId, String resourceXML, String mimeType) throws FileNotFoundException, 
    151162        XMLDBException, IOException { 
    152163                BinaryResource resource = (BinaryResource) collection.createResource(resourceId, "BinaryResource"); 
     
    161172        }        
    162173         
    163         private static void addResource(Collection collection, Resource resource, String resourceXML) throws FileNotFoundException, 
     174        private void addResource(Collection collection, Resource resource, String resourceXML) throws FileNotFoundException, 
    164175        XMLDBException, IOException { 
    165176                resource.setContent(resourceXML); 
     
    168179        } 
    169180         
    170         private static Collection getRootCollection() { 
     181        private Collection getRootCollection() { 
    171182                return rootCollection; 
    172183        } 
    173184         
    174         public static void startExist() throws XMLDBException { 
     185        private void initEnv() { 
     186                System.setProperty("exist.initdb", "true"); 
     187                String existHome = System.getProperty("exist.home"); 
     188                File logs = new File(existHome + "/logs"); 
     189                logs.mkdir(); 
     190                File data = new File(existHome + "/data"); 
     191                data.mkdir(); 
     192        } 
     193         
     194        private void initDB(Collection col) throws XMLDBException { 
     195                for (NewmoonManager.MODULES_DEF_COLLECTION def_coll : NewmoonManager.MODULES_DEF_COLLECTION.values()) { 
     196                        createCollection(col, def_coll.getCollectionName()); 
     197                } 
     198        }        
     199         
     200        public void startExist() throws XMLDBException { 
     201                initEnv(); 
    175202                Database database; 
    176203                try { 
     
    179206                        database.setProperty("create-database", "true"); 
    180207                        DatabaseManager.registerDatabase(database); 
     208                        running = true; 
    181209                        // initialize the deafult DB 
    182210                        // get a collection 
    183211                        rootCollection = getCollection(ROOT_COLLECTION_PATH, "admin", "");; 
    184                         DBManager.initDB(rootCollection); 
     212                        initDB(rootCollection); 
    185213                } catch (ClassNotFoundException e) { 
    186214                        // TODO Auto-generated catch block 
     
    195223        } 
    196224 
    197         public static void stopExist() throws XMLDBException { 
     225        public void stopExist() throws XMLDBException { 
    198226                // shut down the database 
    199227                DatabaseInstanceManager manager = (DatabaseInstanceManager) rootCollection.getService("DatabaseInstanceManager", "1.0"); 
     
    201229        } 
    202230         
    203         public static XQueryService getXQueryService() throws XMLDBException { 
     231        public XQueryService getXQueryService() throws XMLDBException { 
    204232                XQueryService service = (XQueryService) getRootCollection().getService(XQUERY_SERVICE_SERVICE_NAME, 
    205233                                XQUERY_SERVICE_SERVICE_VERSION); 
     
    208236        } 
    209237         
    210         public static void mapDBCollection(final Collection collection) throws XMLDBException { 
    211                 final Collection intCollection = collection == null ? DBManager.getRootCollection() : collection; 
     238        public void mapDBCollection(final Collection collection) throws XMLDBException { 
     239                final Collection intCollection = collection == null ? getRootCollection() : collection; 
    212240                 
    213241                for (String resource : intCollection.listResources()) { 
     
    227255         * @param the path relative to the parent's path 
    228256         **/ 
    229         public static Collection getCollectionChild(Collection collection, String childName) throws XMLDBException { 
    230                 collection = collection == null ? DBManager.getRootCollection() : collection; 
     257        public Collection getCollectionChild(Collection collection, String childName) throws XMLDBException { 
     258                collection = collection == null ? getRootCollection() : collection; 
    231259                return collection.getChildCollection(childName); 
    232260        } 
  • mauRepo/newmoon/src/main/java/ndg/services/newmoon/NewmoonManager.java

    r7815 r7816  
    2626import org.apache.commons.io.filefilter.FileFilterUtils; 
    2727import org.apache.commons.lang.ArrayUtils; 
    28 import org.exist.xmldb.EXistResource; 
    2928import org.exist.xmldb.XQueryService; 
    3029import org.slf4j.Logger; 
     
    3635import org.xmldb.api.base.ResourceSet; 
    3736import org.xmldb.api.base.XMLDBException; 
    38 import org.xmldb.api.modules.BinaryResource; 
    3937import org.xmldb.api.modules.XMLResource; 
    4038 
     
    4543         */ 
    4644        public static final String LSEP = System.getProperty("line.separator"); 
    47          
     45 
    4846        /** 
    4947         * A standard XML 1.0 declaration using UTF-8 encoding. 
    5048         */ 
    51         public static final String XML_DECLARATION_STRING = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";        
    52          
     49        public static final String XML_DECLARATION_STRING = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"; 
     50 
    5351        /** 
    5452         * A suggested prefix value for the results document namespace. 
    5553         */ 
    5654        public static final String RESULTS_NS_SUGGESTED_PREFIX = "cr"; 
    57          
     55 
    5856        /** 
    5957         * The results document root element, local name value. 
     
    6462         * The results document namespace. 
    6563         */ 
    66         public static final String RESULTS_NS = "http://ndg.service.newmoon.conftest-result/1.0";        
     64        public static final String RESULTS_NS = "http://ndg.service.newmoon.conftest-result/1.0"; 
    6765 
    6866        /** 
     
    7068         * test report. 
    7169         */ 
    72         public static final String DEFAULT_REPORT_STYLESHEET = "../resources/conf-test/results-stylesheet.xsl";  
    73  
    74          
     70        public static final String DEFAULT_REPORT_STYLESHEET = "../resources/conf-test/results-stylesheet.xsl"; 
     71 
    7572        public final static String ROOT_COLLECTION_URI = "xmldb:exist:///db"; 
    76          
    77         enum SCHEMA_ENCODING_DEF_COLLECTION{ 
     73 
     74        enum SCHEMA_ENCODING_DEF_COLLECTION { 
    7875                XMI11EA("xmi11ea"); 
    79                  
     76 
    8077                private final String name; 
    8178 
     
    8784                        return "schema-encoding/" + this.name; 
    8885                } 
    89                  
     86 
    9087                public String getEncodingName() { 
    9188                        return this.name; 
     
    105102                        return "modules/" + this.name; 
    106103                } 
    107                  
     104 
    108105                public String getModuleName() { 
    109106                        return this.name; 
    110                 }                
     107                } 
    111108        } 
    112109 
     
    124121                } 
    125122        } 
    126          
     123 
    127124        enum RULES_ROOT_PATH { 
    128125                ISO19136_V3_2_AnxE_XMI_V1_1("rules/conformance-test/ISO19136-V3.2-AnxE_XMI-V1.1"), XMI11EA( 
     
    147144         * The outputDir. 
    148145         */ 
    149         public static final String OUTPUT_DIR = "/home/users/mnagni/workspace/fullmoon/newmoon/target/classes";  
    150          
     146        public static final String OUTPUT_DIR = "/home/users/mnagni/workspace/fullmoon/newmoon/target/classes"; 
     147 
    151148        /** 
    152149         * Name of the default output report name (with no posfix). Currently used 
     
    155152        public static final String DEFAULT_REPORT_NAME = "ConformanceTestReport"; 
    156153        public static final String DEFAULT_ENCODE_REPORT_NAME = "EncodeReport"; 
    157          
     154 
    158155        /** 
    159156         * Logger for this class. 
     
    161158        private static final Logger LOG = LoggerFactory.getLogger(NewmoonManager.class); 
    162159 
    163         // initialize driver 
    164         private final static String OFFSET = "target/"; 
    165          
    166160        private static final Map<String, Object> variables = new HashMap<String, Object>(); 
    167161 
    168         public static void initEnv() { 
    169                 File logs = new File(OFFSET + "logs"); 
    170                 logs.mkdir(); 
    171                 File data = new File(OFFSET + "data"); 
    172                 data.mkdir(); 
    173         } 
    174  
    175         private static Collection loadQueries(String moduleCollectionName, Collection aCollection, RULES_ROOT_PATH queryDir) 
    176                         throws XMLDBException { 
    177                 Collection col = DBManager.createCollection(aCollection, moduleCollectionName); 
    178                 try { 
    179                         addModule(col, queryDir.getRulePath()); 
    180                 } catch (IOException e) { 
    181                         // here have to delete the created collection 
    182                         e.printStackTrace(); 
    183                         col = null; 
    184                 } 
     162        private Collection loadQueries(String moduleCollectionName, Collection aCollection, RULES_ROOT_PATH queryDir) 
     163                        throws XMLDBException, IOException { 
     164                Collection col = DBManager.getInstance().createCollection(aCollection, moduleCollectionName); 
     165                addModule(col, queryDir.getRulePath()); 
    185166                return col; 
    186167        } 
    187168 
    188         private static void addModule(Collection col, String path) throws IOException, XMLDBException { 
     169        private void addModule(Collection col, String path) throws IOException, XMLDBException { 
    189170                List<File> modules = getPathChilds(path + "/modules"); 
    190171                for (File file : modules) { 
    191                         DBManager.addBinaryResource(col, file.getName(), file, "application/xquery"); 
    192                 } 
    193         } 
    194  
    195         public static List<File> getPathChilds(String path) throws IOException { 
     172                        DBManager.getInstance().addBinaryResource(col, file.getName(), file, "application/xquery"); 
     173                } 
     174        } 
     175 
     176        public List<File> getPathChilds(String path) throws IOException { 
    196177                Enumeration<URL> rs = XMIEncoder.class.getClassLoader().getResources(path); 
    197178                if (!rs.hasMoreElements()) { 
     
    205186        } 
    206187 
    207         public static void addXMIResource(Collection collection, File file, String resourceId, String collectionName) 
     188        public void addXMIResource(Collection collection, File file, String resourceId, String collectionName) 
    208189                        throws XMLDBException, IOException, NewmoonException { 
    209190                if (null == file) { 
    210191                        throw new NewmoonException("The XMI resource file is NULL"); 
    211                 }                
    212                  
     192                } 
     193 
    213194                if (null == collectionName || collectionName.trim().length() == 0) { 
    214195                        throw new NewmoonException("The XMI resource file collectionName is NULL or empty"); 
    215                 }                
    216                  
    217                 Collection xmiCol = DBManager.createCollection(collection, collectionName); 
     196                } 
     197 
     198                Collection xmiCol = DBManager.getInstance().createCollection(collection, collectionName); 
    218199                xmiCol.setProperty("encoding", "UTF-8"); 
    219                 DBManager.addXMLResource(xmiCol, resourceId, file); 
    220         } 
    221  
    222         private static Map<String, Object> getVariablesMap(String reportName, String registryPath) { 
     200                DBManager.getInstance().addXMLResource(xmiCol, resourceId, file); 
     201        } 
     202 
     203        private Map<String, Object> getVariablesMap(String reportName, String registryPath) { 
    223204                if (variables.size() > 0) { 
    224205                        variables.put("reportname", reportName); 
     
    242223 
    243224                // ---->> addProperties(propertiesFile, testRunner); 
    244                 String rootCollectionPath = NewmoonManager.ROOT_COLLECTION_URI;          
     225                String rootCollectionPath = NewmoonManager.ROOT_COLLECTION_URI; 
    245226                rootCollectionPath = rootCollectionPath.replaceAll("^(.*/exist/xmlrpc)(/[^/]*)$", "$2"); 
    246227 
     
    248229                variables.put("root-collection-path", rootCollectionPath); 
    249230                return variables; 
    250         }  
    251          
     231        } 
     232 
    252233        /** 
    253234         * Runs the suite of pre- and post-processing XQueries. 
    254          */ 
    255         protected static List<Resource> executePreProcessingScripts(Resource xmiDoc, RULES rules, RULES_ROOT_PATH rulesDir, String reportName, String registryPath) 
    256                         throws IOException, XMLDBException { 
     235         *  
     236         * @throws IOException 
     237         */ 
     238        protected List<Resource> executePreProcessingScripts(Resource xmiDoc, RULES rules, RULES_ROOT_PATH rulesDir, 
     239                        String reportName, String registryPath) throws IOException { 
    257240 
    258241                List<Resource> results = new ArrayList<Resource>(); 
     
    260243 
    261244                if (rules.getRuleName().trim().length() > 0) { 
    262                         queryTests = NewmoonManager.getPathChilds(rulesDir.getRulePath() + "/" + rules.getRuleName()); 
     245                        queryTests = getPathChilds(rulesDir.getRulePath() + "/" + rules.getRuleName()); 
    263246                } else { 
    264                         queryTests = NewmoonManager.getPathChilds(rulesDir.getRulePath()); 
     247                        queryTests = getPathChilds(rulesDir.getRulePath()); 
    265248                } 
    266249 
    267250                if (queryTests == null || queryTests.size() == 0) { 
    268251                        return results; 
    269                 }  
    270                  
     252                } 
     253 
    271254                Collections.sort(queryTests, NameFileComparator.NAME_INSENSITIVE_COMPARATOR); 
    272255 
     
    277260 
    278261                        // Add the results to the ConformaceTestResults bean. 
    279                         ResourceSet result = executeXQuery(xmiDoc, file, getVariablesMap(reportName, registryPath)); 
    280                         ResourceIterator rIter = result.getIterator(); 
    281                         while (rIter.hasMoreResources()) 
    282                                 results.add(rIter.nextResource()); 
     262                        ResourceSet result; 
     263                        try { 
     264                                result = executeXQuery(xmiDoc, file, getVariablesMap(reportName, registryPath)); 
     265                                ResourceIterator rIter = result.getIterator(); 
     266                                while (rIter.hasMoreResources()) 
     267                                        results.add(rIter.nextResource()); 
     268                        } catch (XMLDBException e) { 
     269                                // TODO Auto-generated catch block 
     270                                e.printStackTrace(); 
     271                        } 
    283272                } 
    284273                return results; 
    285274        } 
    286          
     275 
    287276        /** 
    288277         * Executes an XPath or XQuery statement on the database and returns the 
     
    290279         *  
    291280         * @param query 
    292          *            the query string - an XPath or XQuery string.  
     281         *            the query string - an XPath or XQuery string. 
    293282         *  
    294283         * @param externalVariables 
     
    300289         * @throws XMLDBException 
    301290         *             if there is an error executing the query. 
    302          * @throws IOException  
    303          * @throws FileNotFoundException  
    304          */ 
    305         private static ResourceSet executeXQuery(Resource resource, File query, 
    306                         Map<String, Object> externalVariables) throws XMLDBException, FileNotFoundException, IOException { 
    307                 XQueryService service = DBManager.getXQueryService(); 
     291         * @throws IOException 
     292         * @throws FileNotFoundException 
     293         */ 
     294        private ResourceSet executeXQuery(Resource resource, File query, Map<String, Object> externalVariables) 
     295                        throws XMLDBException, FileNotFoundException, IOException { 
     296                XQueryService service = DBManager.getInstance().getXQueryService(); 
    308297                if (null != externalVariables) { 
    309298                        Iterator<String> keys = externalVariables.keySet().iterator(); 
     
    314303                        } 
    315304                } 
    316                 //CompiledExpression compiled = service.compile(preProcessQuery(query)); 
    317305                CompiledExpression compiled = service.compile(IOUtils.toString(new FileReader(query))); 
    318                 return service.execute((XMLResource)resource, compiled); 
    319         }        
    320          
    321         public static InputStream precessResource(Resource xmiResource,  
    322                         String resourceID,  
    323                         RULES_ROOT_PATH rulesDir,  
    324                         MODULES_DEF_COLLECTION collectionName,  
    325                         String reportName, String registryPath) { 
     306                return service.execute((XMLResource) resource, compiled); 
     307        } 
     308 
     309        public InputStream precessResource(Resource xmiResource, String resourceID, RULES_ROOT_PATH rulesDir, 
     310                        MODULES_DEF_COLLECTION collectionName, String reportName, String registryPath) { 
    326311                InputStream ret = null; 
    327                 try {            
     312                try { 
    328313                        String moduleCollectionName = collectionName.getCollectionName() + "/" + rulesDir.getRuleName(); 
    329314                        loadQueries(moduleCollectionName, null, rulesDir); 
    330315 
    331                         List<Resource> results = new ArrayList<Resource>();                      
     316                        List<Resource> results = new ArrayList<Resource>(); 
    332317                        List<Resource> pre = executePreProcessingScripts(xmiResource, RULES.PRE, rulesDir, reportName, registryPath); 
    333318                        results.addAll(pre); 
    334                          
    335                         List<Resource> tests = executePreProcessingScripts(xmiResource, RULES.TESTS, rulesDir, reportName, registryPath); 
     319 
     320                        List<Resource> tests = executePreProcessingScripts(xmiResource, RULES.TESTS, rulesDir, reportName, 
     321                                        registryPath); 
    336322                        results.addAll(tests); 
    337                          
    338                         List<Resource> post = executePreProcessingScripts(xmiResource, RULES.POST, rulesDir, reportName, registryPath); 
     323 
     324                        List<Resource> post = executePreProcessingScripts(xmiResource, RULES.POST, rulesDir, reportName, 
     325                                        registryPath); 
    339326                        results.addAll(post); 
    340                          
     327 
    341328                        ret = reportToFile(resourceID, DEFAULT_REPORT_STYLESHEET, results, reportName); 
    342329                } catch (XMLDBException e) { 
     
    348335                } 
    349336                return ret; 
    350         }        
    351          
     337        } 
     338 
    352339        /** 
    353340         * Serialises the current state of the results collection to an XML document 
     
    356343         * @return an XML representation of the current state of the results 
    357344         *         collection. 
    358          * @throws XMLDBException  
    359          * @throws IOException  
    360          */ 
    361         public static InputStream reportToFile(String resourceID, String stylesheet, List<Resource> results, String reportName) throws XMLDBException, IOException { 
    362                         final String LS = LSEP; 
    363                         StringBuffer buffy = new StringBuffer(XML_DECLARATION_STRING).append(LS); 
    364                         buffy.append("<?xml-stylesheet type=\"text/xsl\" href=\"").append(stylesheet).append("\"?>").append(LS); 
    365                         buffy.append("<").append(RESULTS_NS_SUGGESTED_PREFIX).append(":"); 
    366                         buffy.append(RESULTS_ELEMENT_LOCAL_NAME).append(" xmlns:").append(RESULTS_NS_SUGGESTED_PREFIX); 
    367                         buffy.append("=\"").append(RESULTS_NS).append("\""); 
    368                         if (resourceID != null) 
    369                                 buffy.append(" resource=\"" + resourceID + "\""); 
    370                         buffy.append(">").append(LS); 
    371  
    372                         for(Resource result : results) { 
    373                                 buffy.append((String)result.getContent()).append(LS); 
    374                         } 
    375                         // Append each result to the root element. 
    376                         int resultCount = results.size(); 
    377                         for (int i = 0; i < resultCount; i++) 
    378                         { 
    379                                  
    380                         } 
    381                         buffy.append("</").append(RESULTS_NS_SUGGESTED_PREFIX).append(":"); 
    382                         buffy.append(RESULTS_ELEMENT_LOCAL_NAME).append(">").append(LS); 
    383                          
    384                         // Write out the raw XML report. 
    385                         String reportPath = OUTPUT_DIR + "/" + reportName + ".xml"; 
    386                         File fXmlReport = new File(reportPath); 
    387                         FileWriter writer = new FileWriter(fXmlReport); 
    388                         writer.write(buffy.toString()); 
    389                         writer.flush(); 
    390                         writer.close(); 
    391                         return (InputStream) new FileInputStream(fXmlReport); 
    392         } 
    393          
    394         public static List<String> exportGeneratedResource(String collectionPath) throws NewmoonException, XMLDBException{ 
     345         * @throws XMLDBException 
     346         * @throws IOException 
     347         */ 
     348        public InputStream reportToFile(String resourceID, String stylesheet, List<Resource> results, String reportName) 
     349                        throws XMLDBException, IOException { 
     350                final String LS = LSEP; 
     351                StringBuffer buffy = new StringBuffer(XML_DECLARATION_STRING).append(LS); 
     352                buffy.append("<?xml-stylesheet type=\"text/xsl\" href=\"").append(stylesheet).append("\"?>").append(LS); 
     353                buffy.append("<").append(RESULTS_NS_SUGGESTED_PREFIX).append(":"); 
     354                buffy.append(RESULTS_ELEMENT_LOCAL_NAME).append(" xmlns:").append(RESULTS_NS_SUGGESTED_PREFIX); 
     355                buffy.append("=\"").append(RESULTS_NS).append("\""); 
     356                if (resourceID != null) 
     357                        buffy.append(" resource=\"" + resourceID + "\""); 
     358                buffy.append(">").append(LS); 
     359 
     360                for (Resource result : results) { 
     361                        buffy.append((String) result.getContent()).append(LS); 
     362                } 
     363                // Append each result to the root element. 
     364                int resultCount = results.size(); 
     365                for (int i = 0; i < resultCount; i++) { 
     366 
     367                } 
     368                buffy.append("</").append(RESULTS_NS_SUGGESTED_PREFIX).append(":"); 
     369                buffy.append(RESULTS_ELEMENT_LOCAL_NAME).append(">").append(LS); 
     370 
     371                // Write out the raw XML report. 
     372                String reportPath = OUTPUT_DIR + "/" + reportName + ".xml"; 
     373                File fXmlReport = new File(reportPath); 
     374                FileWriter writer = new FileWriter(fXmlReport); 
     375                writer.write(buffy.toString()); 
     376                writer.flush(); 
     377                writer.close(); 
     378                return (InputStream) new FileInputStream(fXmlReport); 
     379        } 
     380 
     381        public List<String> exportGeneratedResource(String collectionPath) throws NewmoonException, XMLDBException { 
    395382                List<String> encodeFilePaths = new ArrayList<String>(); 
    396                 Collection collection = DBManager.getCollection(null, collectionPath); 
     383                Collection collection = DBManager.getInstance().getCollection(null, collectionPath); 
    397384                String[] collectionResources = collection.listResources(); 
    398385                if (ArrayUtils.isEmpty(collectionResources)) { 
     
    401388                } 
    402389                for (String item : collectionResources) { 
    403                         Resource resource = DBManager.getResource(collection, item); 
     390                        Resource resource = DBManager.getInstance().getResource(collection, item); 
    404391                        String docString = null; 
    405392                        try { 
     
    421408                                writer.close(); 
    422409                                if (LOG.isInfoEnabled()) { 
    423                                         LOG.info("Saved " + item + " to directory " + OUTPUT_DIR);       
     410                                        LOG.info("Saved " + item + " to directory " + OUTPUT_DIR); 
    424411                                } 
    425412                                encodeFilePaths.add(tmpFile.getAbsolutePath()); 
     
    430417                return encodeFilePaths; 
    431418        } 
    432          
     419 
    433420        /** 
    434421         * Perform post-generation clean-up procedure on XDS documents. 
    435422         */ 
    436         private static String postGenerationCleanUp(String xsdDoc) 
    437         { 
     423        private String postGenerationCleanUp(String xsdDoc) { 
    438424                Pattern p = Pattern.compile("\\s+\\S+:dummy=\"\""); 
    439425                Matcher m = p.matcher(xsdDoc); 
  • mauRepo/newmoon/src/main/java/ndg/services/newmoon/ReportError.java

    r7815 r7816  
    55 
    66class ReportError { 
    7          
     7          
    88        final private String errorType; 
    99        final private String errorMessage; 
     10        final private String customMessage; 
    1011         
    11         public ReportError(String errorType, String errorMessage) { 
     12        public ReportError(String customMessage, String errorType, String errorMessage) { 
    1213                super(); 
    1314                this.errorType = errorType; 
    1415                this.errorMessage = errorMessage; 
     16                this.customMessage = customMessage; 
    1517        } 
    1618 
    1719        @Override 
    1820        public String toString() { 
    19                 return "ReportError [errorMessage=" + errorMessage + ", errorType=" + errorType + "]"; 
     21                return "ReportError: " + customMessage + " [errorMessage=" + errorMessage + ", errorType=" + errorType + "]"; 
    2022        } 
    2123} 
  • mauRepo/newmoon/src/main/java/ndg/services/newmoon/XMIEncoder.java

    r7815 r7816  
    44import java.io.IOException; 
    55import java.io.InputStream; 
    6 import java.net.URL; 
    76import java.util.List; 
    87 
     
    1312import ndg.services.newmoon.NewmoonManager.RULES_ROOT_PATH; 
    1413 
     14import org.apache.commons.io.IOUtils; 
     15import org.apache.commons.lang.StringUtils; 
     16import org.apache.commons.lang.text.StrBuilder; 
     17import org.slf4j.Logger; 
     18import org.slf4j.LoggerFactory; 
    1519import org.xmldb.api.base.Collection; 
    1620import org.xmldb.api.base.Resource; 
    1721import org.xmldb.api.base.XMLDBException; 
    1822 
     23public class XMIEncoder { 
    1924 
     25        /** 
     26         * Logger for this class. 
     27         */ 
     28        private static final Logger LOG = LoggerFactory.getLogger(XMIEncoder.class); 
    2029 
    21 public class XMIEncoder { 
    22         /** 
    23          * @param args 
    24          */ 
    25         public static void main(String[] args) { 
    26                 try { 
    27                         NewmoonManager.initEnv(); 
    28                         // start the DB 
    29                         DBManager.startExist(); 
    30                          
    31                         String registryPath = "csml_local_PackageRegister.xml"; 
    32                         String sample = "sampleXML/CSML3.xml"; 
    33                         URL xmiDoc = XMIEncoder.class.getClassLoader().getResource(sample); 
    34                         doEncode(new File(xmiDoc.getPath()), registryPath);                      
    35                 } catch (XMLDBException e) { 
    36                         // TODO Auto-generated catch block 
    37                         e.printStackTrace(); 
    38                 } finally { 
    39                         try { 
    40                                 DBManager.stopExist(); 
    41                         } catch (XMLDBException e) { 
    42                                 // TODO Auto-generated catch block 
    43                                 e.printStackTrace(); 
    44                         }                        
     30        private void checkExistStatus() throws XMLDBException { 
     31                if (!DBManager.isRunning()) { 
     32                        DBManager.getInstance().startExist(); 
    4533                } 
    4634        } 
    47          
    48         public static void doEncode(File xmiDoc, String registryPath) { 
     35 
     36        public void doEncode(File xmiDoc, String registryPath) throws NewmoonException { 
    4937                try { 
    50                         NewmoonManager.initEnv(); 
    51                         // start the DB 
    52                         DBManager.startExist(); 
    53                          
    54                         executeEncode(xmiDoc, registryPath);                     
     38                        checkExistStatus(); 
     39                        executeEncode(xmiDoc, registryPath); 
    5540                } catch (XMLDBException e) { 
    56                         // TODO Auto-generated catch block 
    57                         e.printStackTrace(); 
     41                        throw new NewmoonException(e); 
    5842                } catch (IOException e) { 
    59                         // TODO Auto-generated catch block 
    60                         e.printStackTrace(); 
    61                 } catch (NewmoonException e) { 
    62                         // TODO Auto-generated catch block 
    63                         e.printStackTrace(); 
    64                 } finally { 
    65                         try { 
    66                                 DBManager.stopExist(); 
    67                         } catch (XMLDBException e) { 
    68                                 // TODO Auto-generated catch block 
    69                                 e.printStackTrace(); 
    70                         }                        
     43                        throw new NewmoonException(e); 
    7144                } 
    7245        } 
    73          
    74          
    75         private static List<String> executeEncode(File xmiDoc, String registryPath) throws XMLDBException, IOException, NewmoonException { 
     46 
     47        private List<String> executeEncode(File xmiDoc, String registryPath) throws XMLDBException, IOException, 
     48                        NewmoonException { 
    7649                // add a Sample file 
    7750                String RESOURCE_ID = "CMSLv3"; 
     51                NewmoonManager nm = new NewmoonManager(); 
    7852 
    79                  
    8053                String schemaEncoding = NewmoonManager.SCHEMA_ENCODING_DEF_COLLECTION.XMI11EA.getEncodingName(); 
    81                 NewmoonManager.addXMIResource(null, xmiDoc, RESOURCE_ID, schemaEncoding); 
    82                 Collection xmiCol = DBManager.getCollectionChild(null, schemaEncoding); 
    83                 Resource xmiResource = DBManager.getResource(xmiCol, RESOURCE_ID); 
     54                nm.addXMIResource(null, xmiDoc, RESOURCE_ID, schemaEncoding); 
     55                Collection xmiCol = DBManager.getInstance().getCollectionChild(null, schemaEncoding); 
     56                Resource xmiResource = DBManager.getInstance().getResource(xmiCol, RESOURCE_ID); 
    8457                InputStream is = null; 
    8558 
    86                  
    87                 //Test the XMI File 
    88                 is = NewmoonManager.precessResource(xmiResource, RESOURCE_ID, RULES_ROOT_PATH.ISO19136_V3_2_AnxE_XMI_V1_1, MODULES_DEF_COLLECTION.CONFORMANCE_TEST, NewmoonManager.DEFAULT_REPORT_NAME, registryPath); 
     59                // Test the XMI File 
     60                is = nm.precessResource(xmiResource, RESOURCE_ID, RULES_ROOT_PATH.ISO19136_V3_2_AnxE_XMI_V1_1, 
     61                                MODULES_DEF_COLLECTION.CONFORMANCE_TEST, NewmoonManager.DEFAULT_REPORT_NAME, registryPath); 
    8962                testReport(is); 
    9063 
    91                  
    92                 //Encode the XMI File 
    93                 is = NewmoonManager.precessResource(xmiResource, RESOURCE_ID, RULES_ROOT_PATH.XMI11EA, MODULES_DEF_COLLECTION.SCHEMA_ENCODING, NewmoonManager.DEFAULT_ENCODE_REPORT_NAME, registryPath); 
    94                  
    95                 //Export the generated file 
    96                 return NewmoonManager.exportGeneratedResource(NewmoonManager.SCHEMA_ENCODING_DEF_COLLECTION.XMI11EA.getEncodingCollection() + "/working"); 
    97                  
    98                 //DBManager.mapDBCollection(null); 
     64                // Encode the XMI File 
     65                is = nm.precessResource(xmiResource, RESOURCE_ID, RULES_ROOT_PATH.XMI11EA, 
     66                                MODULES_DEF_COLLECTION.SCHEMA_ENCODING, NewmoonManager.DEFAULT_ENCODE_REPORT_NAME, registryPath); 
     67 
     68                // Export the generated file 
     69                return nm.exportGeneratedResource(NewmoonManager.SCHEMA_ENCODING_DEF_COLLECTION.XMI11EA.getEncodingCollection() 
     70                                + "/working"); 
    9971        } 
    100          
    10172 
    102         private static void testReport(InputStream is) throws NewmoonException { 
     73        private void testReport(InputStream is) throws NewmoonException { 
    10374                ConformanceTestReportManager ctr = new ConformanceTestReportManager(); 
    10475                List<ReportError> errs = null; 
     76                StrBuilder sb = new StrBuilder(); 
    10577                if (is != null) { 
    10678                        try { 
    10779                                errs = ctr.scanForErrors(is); 
    10880                                if (errs != null && !errs.isEmpty()) { 
    109                                         for (ReportError err :errs) { 
    110                                                 System.out.println(err.toString()); 
    111                                         } 
    112                                         throw new NewmoonException("Error in conformance testing"); 
    113                                 }                                
     81                                        for (ReportError err : errs) { 
     82                                                sb.appendln(err.toString()); 
     83                                        }        
     84                                        throw new NewmoonException(sb.toString()); 
     85                                } 
    11486                        } catch (ResourceNotAvailable e) { 
    115                                 // TODO Auto-generated catch block 
    116                                 e.printStackTrace(); 
     87                                LOG.error("Error!", e); 
    11788                        } catch (JAXBException e) { 
    118                                 // TODO Auto-generated catch block 
    119                                 e.printStackTrace(); 
     89                                LOG.error("Error!", e); 
    12090                        } finally { 
    12191                                try { 
    12292                                        is.close(); 
    12393                                } catch (IOException e) { 
    124                                         // TODO Auto-generated catch block 
    125                                         e.printStackTrace(); 
     94                                        LOG.error("Error!", e); 
    12695                                } 
    12796                                is = null; 
  • mauRepo/newmoon/src/test/resources/sampleXML/csml_local_PackageRegister.xml

    r7815 r7816  
    44        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    55        xmlns="urn:x-auscope:xmlns:CSIRO:FullMoon:package-register:2.0" 
    6         xsi:schemaLocation="urn:x-auscope:xmlns:CSIRO:FullMoon:package-register:2.0 ../resources/dependency-util/package-register.xsd" 
     6        xsi:schemaLocation="urn:x-auscope:xmlns:CSIRO:FullMoon:package-register:2.0 ../dependency-util/package-register.xsd" 
    77        id="cim_local_PackageRegister.xml"> 
    88        <description>A register of additional EA packages with classmap implementations for HMA          
     
    1111                <!-- MODIFIED BY DOMINIC LOWE to use LOCAL classmap --> 
    1212                <implementation binding="GML 3.2"> 
    13                    <classMap location="file:///home/users/mnagni/Download/fullmoon/csml3/localClassmaps/ClassMap_ISO_19123_GMLCov_1_0.xml"/> 
     13                        <classMap location="file:///home/users/mnagni/Download/fullmoon/csml3/localClassmaps/ClassMap_ISO_19123_GMLCov_1_0.xml"/> 
    1414                </implementation> 
    1515        </package> 
     
    1818                <implementation binding="GML 3.2"> 
    1919<!--                 <classMap location="file:///usr/local/fullmoon/localclassmaps/ClassMap_ISO_DIS_19156.xml"/> --> 
    20                    <classMap location="https://www.seegrid.csiro.au/subversion/HollowWorld/trunk/ClassMaps/ClassMap_ISO_19156_Observation_GML32.xml"/> 
     20                   <classMap location="https://www.seegrid.csiro.au/subversion/HollowWorld/trunk/ClassMaps/ClassMap_ISO_DIS_19156_Observation_Core_GML32.xml"/> 
    2121                </implementation> 
    2222        </package> 
     23 
    2324</register> 
Note: See TracChangeset for help on using the changeset viewer.