Changeset 760


Ignore:
Timestamp:
05/06/11 23:56:24 (8 years ago)
Author:
philsmart
Message:
 
Location:
raptor-mua/trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • raptor-mua/trunk

    • Property svn:ignore
      •  

        old new  
        11target 
         2 
         3data 
  • raptor-mua/trunk/pom.xml

    r746 r760  
    55        <artifactId>raptor-mua</artifactId> 
    66        <version>0.3-SNAPSHOT</version> 
    7         <packaging>war</packaging> 
     7        <!-- <packaging>jar</packaging> --> 
    88        <name>Raptor Multi-Unit Aggregator</name> 
    99 
     
    387387                </pluginManagement> 
    388388                <plugins> 
    389                         <plugin> 
    390                                 <artifactId>maven-jar-plugin</artifactId> 
    391                                 <configuration> 
    392                                         <archive> 
    393                                                 <manifest> 
    394                                                         <mainClass>uk.ac.cardiff.raptormua.server.RunServer</mainClass> 
    395                                                         <addClasspath>true</addClasspath> 
    396                                                         <classpathPrefix>lib/</classpathPrefix> 
    397                                                 </manifest> 
    398                                         </archive> 
    399                                 </configuration> 
    400                         </plugin> 
     389            <plugin> 
     390                <artifactId>maven-jar-plugin</artifactId> 
     391                <configuration> 
     392                    <finalName>raptor-mua-${project.version}</finalName> 
     393                    <archive> 
     394                        <manifest> 
     395                            <mainClass>uk.ac.cardiff.raptormua.server.RunServer</mainClass> 
     396                            <addClasspath>true</addClasspath> 
     397                            <classpathPrefix>lib/</classpathPrefix> 
     398                        </manifest> 
     399                    </archive> 
     400                </configuration> 
     401            </plugin> 
     402            <plugin> 
     403                <groupId>org.apache.maven.plugins</groupId> 
     404                <artifactId>maven-dependency-plugin</artifactId> 
     405                <executions> 
     406                    <execution> 
     407                        <id>copy-dependencies</id> 
     408                        <phase>package</phase> 
     409                        <goals> 
     410                            <goal>copy-dependencies</goal> 
     411                        </goals> 
     412                        <configuration> 
     413                            <outputDirectory>${project.build.directory}/lib</outputDirectory> 
     414                            <overWriteReleases>true</overWriteReleases> 
     415                            <overWriteSnapshots>true</overWriteSnapshots> 
     416                            <overWriteIfNewer>true</overWriteIfNewer> 
     417                        </configuration> 
     418                    </execution> 
     419                </executions> 
     420            </plugin> 
    401421                        <plugin> 
    402422                                <artifactId>maven-release-plugin</artifactId> 
  • raptor-mua/trunk/src/main/config/dao-beans.xml

    r751 r760  
    2424                <property name="hibernateProperties"> 
    2525                        <props> 
    26                                 <!-- <prop key="hibernate.dialect"> org.hibernate.dialect.PostgreSQLDialect</prop> database type --> 
    27                                 <prop key="hibernate.dialect"> org.hibernate.dialect.HSQLDialect</prop> 
     26                                <!-- <prop key="hibernate.dialect"> org.hibernate.dialect.PostgreSQLDialect</prop> --> 
     27                                 <prop key="hibernate.dialect"> org.hibernate.dialect.HSQLDialect</prop>  
    2828                                <prop key="hibernate.show_sql">false</prop>  
    2929                                <prop key="hibernate.hbm2ddl.auto">update</prop> 
     
    3535                        <list> 
    3636                                <value>uk/ac/cardiff/model/event/event.hbm.xml</value> 
     37                <value>uk/ac/cardiff/model/resource/resourcemetadata.hbm.xml</value> 
    3738                        </list> 
    3839                </property> 
     
    7879        </property> 
    7980        <property name="jdbcUrl"> 
    80             <value>jdbc:hsqldb:file:/tmp/mua;hsqldb.default_table_type=cached</value> 
     81            <value>jdbc:hsqldb:file:data/mua;hsqldb.default_table_type=cached</value> 
    8182        </property> 
    8283        <property name="user"> 
  • raptor-mua/trunk/src/main/config/logback.xml

    r697 r760  
    77  <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender"> 
    88    <encoder> 
    9       <pattern>%5p %d \(%C:%L\) ---&gt; %m%n</pattern> 
     9      <pattern>%5p %t %d \(%C:%L\) ---&gt; %m%n</pattern> 
    1010    </encoder> 
    1111  </appender> 
  • raptor-mua/trunk/src/main/java/uk/ac/cardiff/raptormua/engine/MUAEngine.java

    r746 r760  
    2121import java.util.ArrayList; 
    2222import java.util.List; 
    23  
    2423 
    2524import org.slf4j.Logger; 
     
    5150/** 
    5251 * @author philsmart 
    53  * 
     52 *  
    5453 */ 
    5554public class MUAEngine { 
    5655 
    57     /** Class logger */ 
    58     private final Logger log = LoggerFactory.getLogger(MUAEngine.class); 
    59  
    60     /** Performs all statistics */ 
    61     private StatisticsHandler statisticsHandler; 
    62  
    63     /** The client that is used to process, filter and send events to another MUA instance */ 
    64     private EventReleaseClient eventReleaseClient; 
    65  
    66     // TODO implement user level control on the MUA? 
    67     private Users users; 
    68  
    69     /** The Storage Engine that handles all storage transactions */ 
    70     private StorageEngine storageEngine; 
    71  
    72     /** Metadata about the this MUA instance */ 
    73     private ServiceMetadata muaMetadata; 
    74  
    75     /** Used to parse batch uploads */ 
    76     private DataAccessRegister dataAccessRegister; 
    77  
    78     public MUAEngine() { 
    79         log.info("Setup Multi-Unit Aggregator Engine..."); 
    80         log.info("Mulit-Unit Aggregator Engine is running..."); 
    81     } 
    82  
    83     public void setStatisticsHandler(StatisticsHandler statisticsHandler) { 
    84         this.statisticsHandler = statisticsHandler; 
    85     } 
    86  
    87     public StatisticsHandler getStatisticsHandler() { 
    88         return statisticsHandler; 
    89     } 
    90  
    91     /** 
    92      * @param statisticName 
    93      */ 
    94     public AggregatorGraphModel performStatistic(String statisticName) { 
    95         // TODO we do not need to set this each time 
    96         statisticsHandler.setEntryHandler(storageEngine.getEntryHandler()); 
    97         return statisticsHandler.peformStatistic(statisticName); 
    98  
    99     } 
    100  
    101     /** 
    102      * Gets the capabilities of this MUA, also sets some default values and possible values for the calling component to use 
    103      * 
    104      * @return 
    105      */ 
    106     public Capabilities getCapabilities() { 
    107  
    108         List<Statistic> su = statisticsHandler.getStatisticalUnits(); 
    109  
    110         Capabilities capabilities = new Capabilities(); 
    111         capabilities.setMetadata(this.getMuaMetadata()); 
    112  
    113         // set possible values 
    114         SuggestionValues suggestionValues = new SuggestionValues(); 
    115         suggestionValues.setPossibleFieldNameValues(ReflectionHelper.getFieldsFromEntrySubClasses()); 
    116         capabilities.setSuggestionValues(suggestionValues); 
    117         capabilities.setNumberOfAuthenticationsStored(storageEngine.getEntryHandler().getNumberOfEntries()); 
    118  
    119  
    120         ArrayList<StatisticalUnitInformation> stats = new ArrayList(); 
    121         for (Statistic entry : su) { 
    122             log.debug("Setting statistical unit information as: " + entry.getStatisticParameters().getUnitName()); 
    123             StatisticalUnitInformation information = new StatisticalUnitInformation(); 
    124  
    125             information.setStatisticParameters(entry.getStatisticParameters()); 
    126  
    127             ArrayList<String> postprocessors = new ArrayList(); 
    128             if (entry.getPostprocessor() != null) { 
    129                 for (StatisticsPostProcessor postprocessor : entry.getPostprocessor()) { 
    130                     postprocessors.add(postprocessor.getClass().getSimpleName()); 
    131                 } 
    132             } 
    133             information.setPostprocessors(postprocessors); 
    134  
    135             ArrayList<String> preprocessors = new ArrayList(); 
    136             if (entry.getPreprocessor() != null) 
    137                 preprocessors.add(entry.getPreprocessor().getClass().getSimpleName()); 
    138             information.setPreprocessors(preprocessors); 
    139  
    140             stats.add(information); 
    141         } 
    142         capabilities.setStatisticalServices(stats); 
    143         log.debug("Constructed MUA Capabilities, {}", capabilities); 
    144         return capabilities; 
    145     } 
    146  
    147     /** 
    148      * Use the configured raptor parsing library to store the incomming <code>uploadFiles</code> 
    149      * 
    150      * @param uploadFiles 
    151      *            the files to parse and store 
    152      * @throws TransactionInProgressException 
    153      */ 
    154     public List<LogFileUploadResult>  batchParse(List<LogFileUpload> uploadFiles) throws TransactionInProgressException { 
    155         log.info("Going to parse {} batch uploaded files",uploadFiles.size()); 
    156         ArrayList<Event> allEvents = new ArrayList<Event>(); 
    157  
    158         ArrayList<LogFileUploadResult> results = new ArrayList<LogFileUploadResult>(); 
    159  
    160         for (LogFileUpload logfileUpload : uploadFiles){ 
    161             LogFileUploadResult result = new LogFileUploadResult(); 
    162             result.setId(logfileUpload.getId()); 
    163             try { 
    164                 BaseEventParser parser = dataAccessRegister.getParsingModuleForType(logfileUpload.getEventType().friendlyName); 
    165                 log.debug("Parsing {} using parser {} for type {}",new Object[]{logfileUpload.getName(),parser.getClass(),logfileUpload.getEventType()}); 
    166                 parser.parse(logfileUpload.getData()); 
    167                 allEvents.addAll(parser.getEntryHandler().getEntries()); 
    168                 parser.removeAllEntries(); 
    169                 result.setStatus("Parsed On the MUA"); 
    170                 result.setProcessed(true); 
    171  
    172             } catch (ParserException e) { 
    173                 log.error("Error Parsing the batch uploaded log file {}, with reason",logfileUpload.getName(),e.getMessage()); 
    174                 result.setStatus("Failed To Parse"); 
    175                 result.setProcessed(false); 
    176             } catch (EventParserNotFoundException e){ 
    177                 log.error("Event parser could not be found for {}, with reason {}",logfileUpload.getName(),e.getMessage()); 
    178                 result.setStatus("Failed To Parse"); 
    179                 result.setProcessed(false); 
    180             } 
    181             results.add(result); 
    182         } 
    183         log.info("Storing all {} parsed events",allEvents.size()); 
    184         int transactionId = (int) (Math.random() * 1000000); 
    185         storageEngine.performAsynchronousEntryStoragePipeline(transactionId, allEvents); 
    186  
    187         return results; 
    188  
    189     } 
    190  
    191     /** 
    192      * @param statisticalUnitInformation 
    193      */ 
    194     public void updateStatisticalUnit(StatisticalUnitInformation statisticalUnitInformation) { 
    195         log.debug("Updating Statistical Unit {}", statisticalUnitInformation.getStatisticParameters().getUnitName()); 
    196         statisticsHandler.updateStatisticalUnit(statisticalUnitInformation); 
    197  
    198     } 
    199  
    200     /** 
    201      * @param function 
    202      * @return 
    203      */ 
    204     public boolean performAdministrativeFunction(AdministrativeFunction function) { 
    205         switch (function.getAdministrativeFunction()) { 
    206             case REMOVEALL: 
    207                 storageEngine.removeAllEntries(); 
    208                 break; 
    209         } 
    210         return true; 
    211     } 
    212  
    213     /** 
    214      * @param pushed 
    215      * @throws TransactionInProgressException 
    216      */ 
    217     public void addAuthentications(EventPushMessage pushed) throws TransactionInProgressException { 
    218         int transactionId = (int) (Math.random() * 1000000); 
    219         storageEngine.performAsynchronousEntryStoragePipeline(transactionId, pushed.getEvents()); 
    220  
    221     } 
    222  
    223     public void setMuaMetadata(ServiceMetadata muaMetadata) { 
    224         this.muaMetadata = muaMetadata; 
    225     } 
    226  
    227     public ServiceMetadata getMuaMetadata() { 
    228         return muaMetadata; 
    229     } 
    230  
    231     public void setEventReleaseClient(EventReleaseClient eventReleaseClient) { 
    232         this.eventReleaseClient = eventReleaseClient; 
    233     } 
    234  
    235     public EventReleaseClient getEventReleaseClient() { 
    236         return eventReleaseClient; 
    237     } 
    238  
    239     /** 
    240      * @param storageEngine 
    241      *            the storageEngine to set 
    242      */ 
    243     public void setStorageEngine(StorageEngine storageEngine) { 
    244         this.storageEngine = storageEngine; 
    245     } 
    246  
    247     /** 
    248      * @return the storageEngine 
    249      */ 
    250     public StorageEngine getStorageEngine() { 
    251         return storageEngine; 
    252     } 
    253  
    254     /** 
    255      * @param dataAccessRegister the dataAccessRegister to set 
    256      */ 
    257     public void setDataAccessRegister(DataAccessRegister dataAccessRegister) { 
    258         this.dataAccessRegister = dataAccessRegister; 
    259     } 
    260  
    261     /** 
    262      * @return the dataAccessRegister 
    263      */ 
    264     public DataAccessRegister getDataAccessRegister() { 
    265         return dataAccessRegister; 
    266     } 
    267  
     56        /** Class logger. */ 
     57        private final Logger log = LoggerFactory.getLogger(MUAEngine.class); 
     58 
     59        /** Performs all statistics. */ 
     60        private StatisticsHandler statisticsHandler; 
     61 
     62        /** 
     63         * The client that is used to process, filter and send events to another MUA 
     64         * instance. 
     65         */ 
     66        private EventReleaseClient eventReleaseClient; 
     67 
     68        // TODO implement user level control on the MUA? 
     69        /** Support for user classification on the MUA. */ 
     70        private Users users; 
     71 
     72        /** The Storage Engine that handles all storage transactions. */ 
     73        private StorageEngine storageEngine; 
     74 
     75        /** Metadata about the this MUA instance. */ 
     76        private ServiceMetadata muaMetadata; 
     77 
     78        /** Used to parse batch uploads. */ 
     79        private DataAccessRegister dataAccessRegister; 
     80 
     81        public MUAEngine() { 
     82                log.info("Setup Multi-Unit Aggregator Engine..."); 
     83                log.info("Mulit-Unit Aggregator Engine is running..."); 
     84        } 
     85 
     86        /** 
     87         * Sets the statisticalhandler. 
     88         *  
     89         * @param statisticsHandler 
     90         *            the statistichandler to set 
     91         */ 
     92        public final void setStatisticsHandler(final StatisticsHandler statisticsHandler) { 
     93                this.statisticsHandler = statisticsHandler; 
     94        } 
     95 
     96        public final StatisticsHandler getStatisticsHandler() { 
     97                return statisticsHandler; 
     98        } 
     99 
     100        /** 
     101         * @param statisticName 
     102         */ 
     103        public final AggregatorGraphModel performStatistic(final String statisticName) { 
     104                // TODO we do not need to set this each time 
     105                statisticsHandler.setEntryHandler(storageEngine.getEntryHandler()); 
     106                return statisticsHandler.peformStatistic(statisticName); 
     107 
     108        } 
     109 
     110        /** 
     111         * Gets the capabilities of this MUA, also sets some default values and 
     112         * possible values for the calling component to use 
     113         *  
     114         * @return 
     115         */ 
     116        public final Capabilities getCapabilities() { 
     117 
     118                List<Statistic> su = statisticsHandler.getStatisticalUnits(); 
     119 
     120                Capabilities capabilities = new Capabilities(); 
     121                capabilities.setMetadata(this.getMuaMetadata()); 
     122 
     123                // set possible values 
     124                SuggestionValues suggestionValues = new SuggestionValues(); 
     125                suggestionValues.setPossibleFieldNameValues(ReflectionHelper.getFieldsFromEntrySubClasses()); 
     126                capabilities.setSuggestionValues(suggestionValues); 
     127                capabilities.setNumberOfAuthenticationsStored(storageEngine.getEntryHandler().getNumberOfEntries()); 
     128 
     129                ArrayList<StatisticalUnitInformation> stats = new ArrayList(); 
     130                for (Statistic entry : su) { 
     131                        log.debug("Setting statistical unit information as: " + entry.getStatisticParameters().getUnitName()); 
     132                        StatisticalUnitInformation information = new StatisticalUnitInformation(); 
     133 
     134                        information.setStatisticParameters(entry.getStatisticParameters()); 
     135 
     136                        ArrayList<String> postprocessors = new ArrayList<String>(); 
     137                        if (entry.getPostprocessor() != null) { 
     138                                for (StatisticsPostProcessor postprocessor : entry.getPostprocessor()) { 
     139                                        postprocessors.add(postprocessor.getClass().getSimpleName()); 
     140                                } 
     141                        } 
     142                        information.setPostprocessors(postprocessors); 
     143 
     144                        ArrayList<String> preprocessors = new ArrayList<String>(); 
     145                        if (entry.getPreprocessor() != null) { 
     146                                preprocessors.add(entry.getPreprocessor().getClass().getSimpleName()); 
     147                        } 
     148                        information.setPreprocessors(preprocessors); 
     149 
     150                        stats.add(information); 
     151                } 
     152                capabilities.setStatisticalServices(stats); 
     153                log.debug("Constructed MUA Capabilities, {}", capabilities); 
     154                return capabilities; 
     155        } 
     156 
     157        /** 
     158         * Use the configured raptor parsing library to store the incomming 
     159         * <code>uploadFiles</code> 
     160         *  
     161         * @param uploadFiles 
     162         *            the files to parse and store 
     163         * @throws TransactionInProgressException 
     164         */ 
     165        public final List<LogFileUploadResult> batchParse(final List<LogFileUpload> uploadFiles) throws TransactionInProgressException { 
     166                log.info("Going to parse {} batch uploaded files", uploadFiles.size()); 
     167                ArrayList<Event> allEvents = new ArrayList<Event>(); 
     168 
     169                ArrayList<LogFileUploadResult> results = new ArrayList<LogFileUploadResult>(); 
     170 
     171                for (LogFileUpload logfileUpload : uploadFiles) { 
     172                        LogFileUploadResult result = new LogFileUploadResult(); 
     173                        result.setId(logfileUpload.getId()); 
     174                        try { 
     175                                BaseEventParser parser = dataAccessRegister.getParsingModuleForType(logfileUpload.getEventType().friendlyName); 
     176                                log.debug("Parsing {} using parser {} for type {}", new Object[] { logfileUpload.getName(), parser.getClass(), logfileUpload.getEventType() }); 
     177                                parser.parse(logfileUpload.getData()); 
     178                                allEvents.addAll(parser.getEntryHandler().getEntries()); 
     179                                parser.removeAllEntries(); 
     180                                result.setStatus("Parsed On the MUA"); 
     181                                result.setProcessed(true); 
     182 
     183                        } catch (ParserException e) { 
     184                                log.error("Error Parsing the batch uploaded log file {}, with reason", logfileUpload.getName(), e.getMessage()); 
     185 
     186                                result.setStatus("Failed To Parse"); 
     187                                result.setProcessed(false); 
     188                        } catch (EventParserNotFoundException e) { 
     189                                log.error("Event parser could not be found for {}, with reason {}", logfileUpload.getName(), e.getMessage()); 
     190                                 
     191                                result.setStatus("Failed To Parse"); 
     192                                result.setProcessed(false); 
     193                        } 
     194                        results.add(result); 
     195                } 
     196                log.info("Storing all {} parsed events", allEvents.size()); 
     197                int transactionId = (int) (Math.random() * 1000000); 
     198                storageEngine.performAsynchronousEntryStoragePipeline(transactionId, allEvents); 
     199 
     200                return results; 
     201 
     202        } 
     203 
     204        /** 
     205         * @param statisticalUnitInformation 
     206         */ 
     207        public final void updateStatisticalUnit(final StatisticalUnitInformation statisticalUnitInformation) { 
     208                log.debug("Updating Statistical Unit {}", statisticalUnitInformation.getStatisticParameters().getUnitName()); 
     209                statisticsHandler.updateStatisticalUnit(statisticalUnitInformation); 
     210 
     211        } 
     212 
     213        /** 
     214         * @param function 
     215         * @return 
     216         */ 
     217        public final boolean performAdministrativeFunction(final AdministrativeFunction function) { 
     218                switch (function.getAdministrativeFunction()) { 
     219                case REMOVEALL: 
     220                        storageEngine.removeAllEntries(); 
     221                        break; 
     222                default: 
     223                        break; 
     224                } 
     225                return true; 
     226        } 
     227 
     228        /** 
     229         * @param pushed 
     230         * @throws TransactionInProgressException 
     231         */ 
     232        public final void addAuthentications(final EventPushMessage pushed) throws TransactionInProgressException { 
     233                int transactionId = (int) (Math.random() * 1000000); 
     234                storageEngine.performAsynchronousEntryStoragePipeline(transactionId, pushed.getEvents()); 
     235 
     236        } 
     237 
     238        public final void setMuaMetadata(final ServiceMetadata muaMetadata) { 
     239                this.muaMetadata = muaMetadata; 
     240        } 
     241 
     242        public final ServiceMetadata getMuaMetadata() { 
     243                return muaMetadata; 
     244        } 
     245 
     246        public final void setEventReleaseClient(final EventReleaseClient eventReleaseClient) { 
     247                this.eventReleaseClient = eventReleaseClient; 
     248        } 
     249 
     250        public final EventReleaseClient getEventReleaseClient() { 
     251                return eventReleaseClient; 
     252        } 
     253 
     254        /** 
     255         * @param storageEngine 
     256         *            the storageEngine to set 
     257         */ 
     258        public final void setStorageEngine(final StorageEngine storageEngine) { 
     259                this.storageEngine = storageEngine; 
     260        } 
     261 
     262        /** 
     263         * @return the storageEngine 
     264         */ 
     265        public final StorageEngine getStorageEngine() { 
     266                return storageEngine; 
     267        } 
     268 
     269        /** 
     270         * @param dataAccessRegister 
     271         *            the dataAccessRegister to set 
     272         */ 
     273        public final void setDataAccessRegister(final DataAccessRegister dataAccessRegister) { 
     274                this.dataAccessRegister = dataAccessRegister; 
     275        } 
     276 
     277        /** 
     278         * @return the dataAccessRegister 
     279         */ 
     280        public final DataAccessRegister getDataAccessRegister() { 
     281                return dataAccessRegister; 
     282        } 
    268283 
    269284} 
  • raptor-mua/trunk/src/main/java/uk/ac/cardiff/raptormua/service/impl/MUAProcessImpl.java

    r746 r760  
    155155                                success = true; 
    156156                        } catch (Exception e) { 
    157                                 log.error("Error trying to add authentications to this MUA, {}",e.getMessage()); 
     157                                log.error("Error trying to add authentications to this MUA",e); 
    158158 
    159159                        } finally { 
  • raptor-mua/trunk/src/main/resources/package.xml

    r632 r760  
    1818--> 
    1919<assembly> 
    20     <id>package</id> 
     20   <id>package</id> 
    2121    <formats> 
    22         <format>tar.gz</format> 
     22        <format>zip</format> 
    2323    </formats> 
    2424    <fileSets> 
     
    4444            </includes> 
    4545        </fileSet> 
     46        <fileSet> 
     47            <directory>target/bin</directory> 
     48            <outputDirectory>bin</outputDirectory> 
     49            <includes> 
     50                <include>*</include> 
     51            </includes> 
     52        </fileSet> 
    4653    </fileSets> 
    4754</assembly> 
Note: See TracChangeset for help on using the changeset viewer.