Changeset 1446

Timestamp:

27-01-11 14:34:41 (6 years ago)

Author:

robert@…

Message:

Implemented convenience method to call rest methods on modules

Location:

trunk/grails-app

Files:

• domain/dbnp/studycapturing/Study.groovy (modified) (3 diffs)
• services/dbnp/modules (added)
• services/dbnp/modules/ModuleCommunicationService.groovy (moved) (moved from trunk/grails-app/services/dbnp/studycapturing/SynchronizationService.groovy) (2 diffs)
• services/dbnp/modules/ModuleNotificationService.groovy (added)

trunk/grails-app/domain/dbnp/studycapturing/Study.groovy

@@ -4 +4 @@
 import nl.grails.plugins.gdt.*
 import java.util.UUID;
+import dbnp.modules.*;
 
 /**
@@ -16 +17 @@
         static searchable = true
         
-        def synchronizationService
+        def moduleNotificationService
 
         SecUser owner           // The owner of the study. A new study is automatically owned by its creator.
@@ -524 +525 @@
         // Send messages to modules about changes in this study
         def beforeInsert = {
-                synchronizationService.invalidateStudy( this );
+                moduleNotificationService.invalidateStudy( this );
         }
         def beforeUpdate = {
-                synchronizationService.invalidateStudy( this );
+                moduleNotificationService.invalidateStudy( this );
         }
         def beforeDelete = {
-                synchronizationService.invalidateStudy( this );
+                moduleNotificationService.invalidateStudy( this );
         }
 }

trunk/grails-app/services/dbnp/modules/ModuleCommunicationService.groovy

@@ -13 +13 @@
  * $Date$
  */
-package dbnp.studycapturing
+package dbnp.modules
 
 import nl.grails.plugins.gdt.*
-import com.sun.xml.internal.ws.api.streaming.XMLStreamReaderFactory.Default;
+import dbnp.studycapturing.*
+import grails.converters.*
 
-class SynchronizationService implements Serializable {
+class ModuleCommunicationService implements Serializable {
     boolean transactional = false
+        def authenticationService
+        def moduleNotificationService
         
     /**
@@ -35 +38 @@
      */
         def invalidateStudy( Study study ) {
-                if( !study )
-                        return
-                        
-                log.info( "Invalidate " + study.code )
+                moduleNotificationService.invalidateStudy( study );
+    }
+        
+        /**
+         * Checks whether a specific method on a module is reachable and returns a SC_OK response code. 
+         * 
+         * This method will return false if a method returns an error (including 403 and 401 errors) or
+         * a redirect
+         * 
+         * @param moduleUrl             URL of the module
+         * @param path                  Path of the rest method on that module. If omitted, the module reachablility itself is tested
+         * @return                              True if the module is reachable, false otherwise
+         */
+        def isModuleReachable(moduleUrl, path = "") {
+                def connection = ( moduleUrl + path ).toURL().openConnection()
+                try {
+                        return connection.responseCode == HttpServletResponse.SC_OK
+                } catch(e) { 
+                        return false 
+                }
+        }
+        
+        /**
+         * Calls a rest method on a module
+         * 
+         * @param consumer      Consumer of that specific module
+         * @param restUrl       Full URL for the method to call
+         * @return                      JSON    JSON object of the parsed text
+         */
+        def callModuleRestMethodJSON( consumer, restUrl ) throws Exception {
+                // create a random session token that will be used to allow to module to
+                // sync with gscf prior to presenting the measurement data
+                def sessionToken = UUID.randomUUID().toString()
 
-                def modules = AssayModule.findByNotify(true);
-                
-                def urls = []
-                modules.each { module ->
-                        urls << module.url + '/rest/notifyStudyChange?studyToken=' + study.giveUUID()
+                if (!authenticationService.isLoggedIn()) {
+                        // should not happen because we can only get here when a user is
+                        // logged in...
+                        throw new Exception('User is not logged in.')
+                }
+
+                // put the session token to work
+                authenticationService.logInRemotely( consumer, sessionToken, authenticationService.getLoggedInUser() )
+
+                // Append the sessionToken to the URL
+                def url = restUrl
+                if( restUrl.indexOf( '?' ) > 0 ) {
+                        // The url itself also has parameters
+                        url += '&sessionToken=' + sessionToken
+                } else {
+                        // The url itself doesn't have parameters
+                        url += '?sessionToken=' + sessionToken
                 }
                 
-                Thread.start { 
-                        urls.each { url ->
-                                try {
-                                        def connection = url.toURL().openConnection()
-                                        if( connection.responseCode == 200 ) {
-                                                log.info( "GSCF NOTIFY-CALL SUCCEEDED: ${url}" )
-                                        } else {
-                                                log.info( "GSCF NOTIFY-CALL FAILED: ${url}: " + connection.responseCode )
-                                        }
-                                } catch( Exception ignore) {
-                                        log.info( "GSCF NOTIFY-CALL ERROR: ${url} - " + ignore.getMessage() )
-                                }
-                        }
-                 };
-    }
+                // Perform a call to the url
+                def restResponse
+                try {
+                        def textResponse = url.toURL().getText()
+                        restResponse = JSON.parse( textResponse )
+                } catch (Exception e) {
+                        throw new Exception( "An error occurred while fetching " + url + ".", e )
+                } finally {
+                        // Dispose of the ephemeral session token
+                        authenticationService.logOffRemotely(consumer, sessionToken)
+                }
+                
+                return restResponse
+        }
 }