Changeset 1446


Ignore:
Timestamp:
Jan 27, 2011, 2:34:41 PM (6 years ago)
Author:
robert@…
Message:

Implemented convenience method to call rest methods on modules

Location:
trunk/grails-app
Files:
2 added
1 edited
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

    r1445 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}
Note: See TracChangeset for help on using the changeset viewer.