Changeset 1446

Show
Ignore:
Timestamp:
27-01-11 14:34:41 (3 years ago)
Author:
robert@…
Message:

Implemented convenience method to call rest methods on modules

Location:
trunk/grails-app
Files:
2 added
1 modified
1 moved

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/domain/dbnp/studycapturing/Study.groovy

    r1440 r1446  
    44import nl.grails.plugins.gdt.* 
    55import java.util.UUID; 
     6import dbnp.modules.*; 
    67 
    78/** 
     
    1617        static searchable = true 
    1718         
    18         def synchronizationService 
     19        def moduleNotificationService 
    1920 
    2021        SecUser owner           // The owner of the study. A new study is automatically owned by its creator. 
     
    524525        // Send messages to modules about changes in this study 
    525526        def beforeInsert = { 
    526                 synchronizationService.invalidateStudy( this ); 
     527                moduleNotificationService.invalidateStudy( this ); 
    527528        } 
    528529        def beforeUpdate = { 
    529                 synchronizationService.invalidateStudy( this ); 
     530                moduleNotificationService.invalidateStudy( this ); 
    530531        } 
    531532        def beforeDelete = { 
    532                 synchronizationService.invalidateStudy( this ); 
     533                moduleNotificationService.invalidateStudy( this ); 
    533534        } 
    534535} 
  • trunk/grails-app/services/dbnp/modules/ModuleCommunicationService.groovy

    r1442 r1446  
    1313 * $Date$ 
    1414 */ 
    15 package dbnp.studycapturing 
     15package dbnp.modules 
    1616 
    1717import nl.grails.plugins.gdt.* 
    18 import com.sun.xml.internal.ws.api.streaming.XMLStreamReaderFactory.Default; 
     18import dbnp.studycapturing.* 
     19import grails.converters.* 
    1920 
    20 class SynchronizationService implements Serializable { 
     21class ModuleCommunicationService implements Serializable { 
    2122    boolean transactional = false 
     23        def authenticationService 
     24        def moduleNotificationService 
    2225         
    2326    /** 
     
    3538     */ 
    3639        def invalidateStudy( Study study ) { 
    37                 if( !study ) 
    38                         return 
    39                          
    40                 log.info( "Invalidate " + study.code ) 
     40                moduleNotificationService.invalidateStudy( study ); 
     41    } 
     42         
     43        /** 
     44         * Checks whether a specific method on a module is reachable and returns a SC_OK response code.  
     45         *  
     46         * This method will return false if a method returns an error (including 403 and 401 errors) or 
     47         * a redirect 
     48         *  
     49         * @param moduleUrl             URL of the module 
     50         * @param path                  Path of the rest method on that module. If omitted, the module reachablility itself is tested 
     51         * @return                              True if the module is reachable, false otherwise 
     52         */ 
     53        def isModuleReachable(moduleUrl, path = "") { 
     54                def connection = ( moduleUrl + path ).toURL().openConnection() 
     55                try { 
     56                        return connection.responseCode == HttpServletResponse.SC_OK 
     57                } catch(e) {  
     58                        return false  
     59                } 
     60        } 
     61         
     62        /** 
     63         * Calls a rest method on a module 
     64         *  
     65         * @param consumer      Consumer of that specific module 
     66         * @param restUrl       Full URL for the method to call 
     67         * @return                      JSON    JSON object of the parsed text 
     68         */ 
     69        def callModuleRestMethodJSON( consumer, restUrl ) throws Exception { 
     70                // create a random session token that will be used to allow to module to 
     71                // sync with gscf prior to presenting the measurement data 
     72                def sessionToken = UUID.randomUUID().toString() 
    4173 
    42                 def modules = AssayModule.findByNotify(true); 
    43                  
    44                 def urls = [] 
    45                 modules.each { module -> 
    46                         urls << module.url + '/rest/notifyStudyChange?studyToken=' + study.giveUUID() 
     74                if (!authenticationService.isLoggedIn()) { 
     75                        // should not happen because we can only get here when a user is 
     76                        // logged in... 
     77                        throw new Exception('User is not logged in.') 
     78                } 
     79 
     80                // put the session token to work 
     81                authenticationService.logInRemotely( consumer, sessionToken, authenticationService.getLoggedInUser() ) 
     82 
     83                // Append the sessionToken to the URL 
     84                def url = restUrl 
     85                if( restUrl.indexOf( '?' ) > 0 ) { 
     86                        // The url itself also has parameters 
     87                        url += '&sessionToken=' + sessionToken 
     88                } else { 
     89                        // The url itself doesn't have parameters 
     90                        url += '?sessionToken=' + sessionToken 
    4791                } 
    4892                 
    49                 Thread.start {  
    50                         urls.each { url -> 
    51                                 try { 
    52                                         def connection = url.toURL().openConnection() 
    53                                         if( connection.responseCode == 200 ) { 
    54                                                 log.info( "GSCF NOTIFY-CALL SUCCEEDED: ${url}" ) 
    55                                         } else { 
    56                                                 log.info( "GSCF NOTIFY-CALL FAILED: ${url}: " + connection.responseCode ) 
    57                                         } 
    58                                 } catch( Exception ignore) { 
    59                                         log.info( "GSCF NOTIFY-CALL ERROR: ${url} - " + ignore.getMessage() ) 
    60                                 } 
    61                         } 
    62                  }; 
    63     } 
     93                // Perform a call to the url 
     94                def restResponse 
     95                try { 
     96                        def textResponse = url.toURL().getText() 
     97                        restResponse = JSON.parse( textResponse ) 
     98                } catch (Exception e) { 
     99                        throw new Exception( "An error occurred while fetching " + url + ".", e ) 
     100                } finally { 
     101                        // Dispose of the ephemeral session token 
     102                        authenticationService.logOffRemotely(consumer, sessionToken) 
     103                } 
     104                 
     105                return restResponse 
     106        } 
    64107}