Changeset 733


Ignore:
Timestamp:
05/03/11 18:59:07 (8 years ago)
Author:
philsmart
Message:
 
Location:
raptor-mua/trunk
Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed
  • raptor-mua/trunk/.settings/org.eclipse.wst.common.component

    r688 r733  
    77        <wb-resource deploy-path="/WEB-INF/classes" source-path="/src/main/config"/> 
    88        <wb-resource deploy-path="/WEB-INF/classes" source-path="/src/test/java"/> 
    9         <dependent-module deploy-path="/WEB-INF/lib" handle="module:/resource/raptor-client/raptor-client"> 
     9        <dependent-module deploy-path="/WEB-INF/lib" handle="module:/resource/raptor-parse/raptor-parse"> 
    1010            <dependency-type>uses</dependency-type> 
    1111        </dependent-module> 
    12         <dependent-module deploy-path="/WEB-INF/lib" handle="module:/resource/idp-attribute-resolver-api/idp-attribute-resolver-api"> 
    13             <dependency-type>uses</dependency-type> 
    14         </dependent-module> 
    15         <dependent-module deploy-path="/WEB-INF/lib" handle="module:/resource/idp-attribute-api/idp-attribute-api"> 
    16             <dependency-type>uses</dependency-type> 
    17         </dependent-module> 
    18         <dependent-module deploy-path="/WEB-INF/lib" handle="module:/resource/idp-core/idp-core"> 
    19             <dependency-type>uses</dependency-type> 
    20         </dependent-module> 
    21         <dependent-module deploy-path="/WEB-INF/lib" handle="module:/resource/opensaml-util/opensaml-util"> 
    22             <dependency-type>uses</dependency-type> 
    23         </dependent-module> 
    24         <dependent-module deploy-path="/WEB-INF/lib" handle="module:/resource/opensaml-messaging-api/opensaml-messaging-api"> 
    25             <dependency-type>uses</dependency-type> 
    26         </dependent-module> 
    27         <dependent-module deploy-path="/WEB-INF/lib" handle="module:/resource/idp-attribute-resolver-impl/idp-attribute-resolver-impl"> 
     12        <dependent-module deploy-path="/WEB-INF/lib" handle="module:/resource/raptor-client/raptor-client"> 
    2813            <dependency-type>uses</dependency-type> 
    2914        </dependent-module> 
  • raptor-mua/trunk/pom.xml

    r697 r733  
    4040        <dependencies> 
    4141 
     42           <!-- RAPTOR specific dependencies --> 
     43 
     44            <dependency> 
     45            <groupId>uk.ac.cardiff.raptor</groupId> 
     46            <artifactId>raptor-parse</artifactId> 
     47            <version>0.0.1-SNAPSHOT</version> 
     48        </dependency> 
     49 
    4250 
    4351 
     
    268276                        <version>0.9.1.2</version> 
    269277                </dependency> 
    270          
     278 
    271279        <!--  to deal with existing log4j components that do not use slf4j. This bridge pushes those through 
    272280        slf4j and hence then through logback (or the sl4fy implementation) --> 
  • raptor-mua/trunk/src/main/config/mua-core.xml

    r710 r733  
    9393                <property name="storageEngine"><ref bean="storageEngine"></ref></property> 
    9494                <property name="muaMetadata"><ref bean="MUAMetadata"></ref></property> 
     95                <property name="dataAccessRegister"><ref bean="dataAccessRegister"></ref></property> 
    9596        </bean> 
    9697 
     
    138139          <import resource="users.xml" /> 
    139140          <import resource="attribute-association.xml"/> 
     141          <import resource="batch-parser.xml"/> 
    140142 
    141143</beans> 
  • raptor-mua/trunk/src/main/java/uk/ac/cardiff/raptormua/engine/MUAEngine.java

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

    r697 r733  
    6969                setObservationSeries(new ArrayList<ObservationSeries>()); 
    7070        } 
    71          
     71 
    7272        public abstract Boolean performStatistic(ArrayList<MethodParameter> methodParams, String sqlWhere) throws StatisticalUnitException; 
    73          
     73 
    7474 
    7575        /** 
     
    124124                        for (Group group : groups) { 
    125125                                gmodel.addGroupLabel(group.getGroupName()); 
    126                         }                        
     126                        } 
    127127                        //now add each series and their values 
    128128                        for (int i=0; i < observationSeries.size(); i++){ 
     
    163163                                        values.add(valueDouble); 
    164164                                } 
    165                                 log.debug("Adding Values {}",Arrays.toString(values.toArray(new Double[0]))); 
     165                                //log.debug("Adding Values {}",Arrays.toString(values.toArray(new Double[0]))); 
    166166                                gmodel.addGroupValue(values); 
    167167                        } 
     
    194194                } 
    195195        } 
    196          
    197          
     196 
     197 
    198198        protected DateTime startingTime() { 
    199199                if (statisticParameters.getStartTimeAsDate() != null) 
     
    230230                this.postprocessor = postprocessor; 
    231231        } 
    232          
     232 
    233233        public abstract void setStatisticParameters(StatisticParameters statisticParameters) ; 
    234          
    235          
     234 
     235 
    236236        public StatisticParameters getStatisticParameters() { 
    237237                return statisticParameters; 
  • raptor-mua/trunk/src/main/java/uk/ac/cardiff/raptormua/service/MUAProcess.java

    r726 r733  
    2929import uk.ac.cardiff.model.wsmodel.EventPushMessage; 
    3030import uk.ac.cardiff.model.wsmodel.LogFileUpload; 
     31import uk.ac.cardiff.model.wsmodel.LogFileUploadResult; 
    3132import uk.ac.cardiff.model.wsmodel.StatisticalUnitInformation; 
    3233 
     
    6970        public AggregatorGraphModel updateAndInvokeStatisticalUnit(StatisticalUnitInformation statisticalUnitInformation) throws SoapFault; 
    7071 
    71         public boolean batchUpload(List<LogFileUpload> uploadFiles) throws SoapFault; 
     72        public List<LogFileUploadResult> batchUpload(List<LogFileUpload> uploadFiles) throws SoapFault; 
    7273} 
  • raptor-mua/trunk/src/main/java/uk/ac/cardiff/raptormua/service/impl/MUAProcessImpl.java

    r726 r733  
    3535import uk.ac.cardiff.model.wsmodel.EventPushMessage; 
    3636import uk.ac.cardiff.model.wsmodel.LogFileUpload; 
     37import uk.ac.cardiff.model.wsmodel.LogFileUploadResult; 
    3738import uk.ac.cardiff.model.wsmodel.StatisticalUnitInformation; 
     39import uk.ac.cardiff.raptor.store.TransactionInProgressException; 
    3840import uk.ac.cardiff.raptormua.engine.MUAEngine; 
    3941import uk.ac.cardiff.raptormua.service.MUAProcess; 
     
    5860 
    5961        /** 
    60          * ReentrantLock to prevent more than at the same time 
     62         * ReentrantLock to prevent more than one operation at the same time 
    6163         */ 
    6264        final Lock lockR = new ReentrantLock(); 
     
    195197         */ 
    196198        @Override 
    197         public boolean batchUpload(List<LogFileUpload> uploadFiles) throws SoapFault { 
     199        public List<LogFileUploadResult> batchUpload(List<LogFileUpload> uploadFiles) throws SoapFault { 
    198200                log.info("Webservice call to parse {} batch log file(s)",uploadFiles.size()); 
     201 
    199202                for (LogFileUpload logfile : uploadFiles){ 
    200                         log.debug("Log File details: name [{}], MIME type [{}], Length [{}]",new Object[]{logfile.getName(),logfile.getMime(),logfile.getData().length}); 
    201                 } 
    202                 engine.batchParse(uploadFiles); 
    203                 return true; 
     203                        log.debug("Log File details: name [{}], MIME type [{}], Length [{}], ID [{}]",new Object[]{logfile.getName(),logfile.getMime(),logfile.getData().length, logfile.getId()}); 
     204                } 
     205                try{ 
     206                    return engine.batchParse(uploadFiles); 
     207                } 
     208                catch (TransactionInProgressException e){ 
     209                    log.error("Could not parse and store batch upload {}",e.getMessage()); 
     210                    throw new SoapFault("Could not parse and store batch upload "+e.getMessage(),new QName("Server")); 
     211                } 
    204212 
    205213        } 
  • raptor-mua/trunk/src/main/java/uk/ac/cardiff/raptormua/wsinterface/impl/MultiUnitAggregatorImpl.java

    r726 r733  
    3232import uk.ac.cardiff.model.wsmodel.EventPushMessage; 
    3333import uk.ac.cardiff.model.wsmodel.LogFileUpload; 
     34import uk.ac.cardiff.model.wsmodel.LogFileUploadResult; 
    3435import uk.ac.cardiff.model.wsmodel.StatisticalUnitInformation; 
    3536import uk.ac.cardiff.raptor.remoting.server.sei.MultiUnitAggregator; 
     
    9394        } 
    9495 
    95         public boolean batchUpload(List<LogFileUpload> uploadFiles) { 
     96        public List<LogFileUploadResult> batchUpload(List<LogFileUpload> uploadFiles) throws SoapFault{ 
    9697                return processService.batchUpload(uploadFiles); 
    9798        } 
Note: See TracChangeset for help on using the changeset viewer.