Changeset 1596


Ignore:
Timestamp:
Mar 8, 2011, 11:20:31 AM (6 years ago)
Author:
robert@…
Message:

Solved #344 - retrieving module data is now done using POST

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/controllers/dbnp/query/AdvancedQueryController.groovy

    r1526 r1596  
    333333                        def callUrl = module.url + '/rest/getQueryableFields'
    334334                        try {
    335                                 def json = moduleCommunicationService.callModuleRestMethodJSON( module.url, callUrl );
     335                                def json = moduleCommunicationService.callModuleMethod( module.url, callUrl );
    336336                                def moduleFields = [];
    337337                                entitiesToSearchFor.each { entity ->
     
    636636                        } catch( Exception e ) {
    637637                                // Exception is thrown when the call to the module fails. No problems though.
    638                                 log.error "Error while fetching possible actions from " + module.name + ": " + e.getMessage()
     638                                //log.error "Error while fetching possible actions from " + module.name + ": " + e.getMessage()
     639                                e.printStackTrace()
     640                                throw e
    639641                        }
    640642                }
  • trunk/grails-app/services/dbnp/modules/ModuleCommunicationService.groovy

    r1577 r1596  
    8181         * @param restUrl       Full URL for the method to call
    8282         * @return                      JSON    JSON object of the parsed text
     83         * @deprecated          Use callModuleMethod instead
    8384         */
    8485        def callModuleRestMethodJSON( consumer, restUrl ) throws Exception {
     86                def parts = restUrl.split( /\?/ );
     87                def url = "";
     88                def query = "";
     89               
     90                if( parts.size() > 1 ) {
     91                        url = parts[ 0 ]
     92                        query = parts[ 1 ]
     93                } else if( parts.size() > 0 ) {
     94                        url = parts[ 0 ];
     95                }
     96               
     97                return callModuleMethod( consumer, url, query );
     98        }
     99       
     100        /**
     101        * Calls a rest method on a module
     102        *
     103        * @param consumer       Consumer of that specific module
     104        * @param restUrl        Full URL for the method to call, without query string
     105        * @param args           Query string for the url to call (e.q. token=abc&field=xyz)
     106        * @param requestMethod  GET or POST - HTTP request method to use
     107        * @return                       JSON    JSON object of the parsed text
     108        */
     109        def callModuleMethod( String consumer, String restUrl, String args = null, String requestMethod = "GET" ) {
    85110                if (!authenticationService.isLoggedIn()) {
    86111                        // should not happen because we can only get here when a user is
     
    90115
    91116                // Check whether the url is present in cache
    92                 def cacheData = retrieveFromCache( restUrl );
     117                def cacheData = retrieveFromCache( restUrl, args );
    93118                if( cacheData && cacheData[ "success" ] )
    94119                        return cacheData[ "contents" ];
     
    104129               
    105130                // Append the sessionToken to the URL
    106                 def url = restUrl
    107                 if( restUrl.indexOf( '?' ) > 0 ) {
    108                         // The url itself also has parameters
    109                         url += '&sessionToken=' + sessionToken
    110                 } else {
    111                         // The url itself doesn't have parameters
    112                         url += '?sessionToken=' + sessionToken
    113                 }
     131                if( !args )
     132                        args = ""
     133               
     134                args += "&sessionToken=" + sessionToken
    114135               
    115136                // Perform a call to the url
    116137                def restResponse
    117138                try {
    118                         def textResponse = url.toURL().getText()
    119                         log.trace "GSCF call to " + consumer + " URL: " + url
     139                        log.trace "GSCF call (" + requestMethod + ") to " + consumer + " URL: " + restUrl + " (args: " + args + ")"
     140
     141                        def textResponse
     142                        switch( requestMethod.toUpperCase() ) {
     143                                case "GET":
     144                                        def url = restUrl + "?" + args;
     145                                        def connection = url.toURL().openConnection();
     146               
     147                                        textResponse = url.toURL().getText()
     148                               
     149                                        break
     150                                case "POST":
     151                                        def connection = restUrl.toURL().openConnection()
     152                                        connection.setRequestMethod( "POST" );
     153                                        connection.doOutput = true
     154                                       
     155                                        def writer = new OutputStreamWriter( connection.outputStream )
     156                                        writer.write( args );
     157                                        writer.flush()
     158                                        writer.close()
     159                                       
     160                                        connection.connect();
     161                                       
     162                                        textResponse = connection.content.text
     163
     164                                        break
     165                                default:
     166                                        throw new Exception( "Unknown request method given. Use GET or POST" )
     167                        }
     168
    120169                        log.trace "GSCF response: " + textResponse
    121170                        restResponse = JSON.parse( textResponse )
    122171                } catch (Exception e) {
    123                         storeErrorInCache( restUrl, e.getMessage() );
    124                         throw new Exception( "An error occurred while fetching " + url + ".", e )
     172                        storeErrorInCache( restUrl, e.getMessage(), args );
     173                        throw new Exception( "An error occurred while fetching " + restUrl + ".", e )
    125174                } finally {
    126175                        // Dispose of the ephemeral session token
    127                         //authenticationService.logOffRemotely(consumer, sessionToken)
     176                        authenticationService.logOffRemotely(consumer, sessionToken)
    128177                }
    129178
    130179                // Store the response in cache
    131                 storeInCache( restUrl, restResponse );
     180                storeInCache( restUrl, restResponse, args );
    132181               
    133182                return restResponse
    134         }
    135 
     183
     184        }
     185       
    136186        /**
    137187         * Checks whether a specific url exists in cache
     
    139189         * @return              true if the url is present in cache
    140190         */
    141         def existsInCache( url ) {
    142                 return retrieveFromCache( url ) == null;
     191        def existsInCache( url, args = null ) {
     192                return retrieveFromCache( url, args ) == null;
    143193        }
    144194
     
    148198         * @return              JSON object with the contents of the URL or null if the url doesn't exist in cache
    149199         */
    150         def retrieveFromCache( url ) {
     200        def retrieveFromCache( url, args = null ) {
    151201                def user = authenticationService.getLoggedInUser();
    152202                def userId = user ? user.id : -1;
     203               
     204                url = cacheUrl( url, args )
    153205               
    154206                if( cache[ userId ] && cache[ userId ][ url ] && ( System.currentTimeMillis() - cache[ userId ][ url ][ "timestamp" ] ) < numberOfSecondsInCache * 1000 ) {
     
    164216         * @param contents      Contents of the URL
    165217         */
    166         def storeInCache( url, contents ) {
     218        def storeInCache( url, contents, args = null ) {
    167219                def user = authenticationService.getLoggedInUser();
    168220                def userId = user ? user.id : -1;
     
    171223                        cache[ userId ] = [:]
    172224
    173                 cache[ userId ][ url ] = [
     225                cache[ userId ][ cacheUrl( url, args ) ] = [
    174226                        "timestamp": System.currentTimeMillis(),
    175227                        "success": true,
     
    183235        * @param contents       Contents of the URL
    184236        */
    185    def storeErrorInCache( url, error ) {
     237   def storeErrorInCache( url, error, args = null ) {
    186238           def user = authenticationService.getLoggedInUser();
    187239           def userId = user ? user.id : -1;
     
    190242                   cache[ userId ] = [:]
    191243
    192            cache[ userId ][ url ] = [
     244           cache[ userId ][ cacheUrl( url, args ) ] = [
    193245                   "timestamp": System.currentTimeMillis(),
    194246                   "success": false,
     
    196248           ];
    197249   }
     250   
     251   /**
     252    * Url used to save data in cache
     253    */
     254   def cacheUrl( url, args = null ) {
     255                if( args ) {
     256                        // Remove sessionToken from args
     257                        args = args;
     258                        def sessionFound = ( args =~ /sessionToken=[^&]/ );
     259                        args = sessionFound.replaceAll( "sessionToken=" );
     260                       
     261                        url += '?' + args
     262                }
     263                       
     264                return url;
     265   }
    198266
    199267}
  • trunk/src/groovy/dbnp/query/Search.groovy

    r1590 r1596  
    517517               
    518518                                        if( moduleCriteria && moduleCriteria.size() > 0 ) {
    519                                                 def callUrl = moduleCriteriaUrl( module, entities, moduleCriteria );
     519                                                def callUrl = moduleCriteriaUrl( module );
     520                                                def callArgs = moduleCriteriaArguments( module, entities, moduleCriteria );
    520521                                               
    521522                                                try {
    522                                                         def json = moduleCommunicationService.callModuleRestMethodJSON( module.url, callUrl );
     523                                                        def json = moduleCommunicationService.callModuleMethod( module.url, callUrl, callArgs, "POST" );
    523524                                                        Closure checkClosure = moduleCriterionClosure( json );
    524525                                                        entities = filterEntityList( entities, moduleCriteria, checkClosure );
    525526                                                } catch( Exception e ) {
    526                                                         log.error( "Error while retrieving data from " + module.name + ": " + e.getMessage() )
     527                                                        //log.error( "Error while retrieving data from " + module.name + ": " + e.getMessage() )
     528                                                        e.printStackTrace()
     529                                                        throw e
    527530                                                }
    528531                                        }
     
    541544               
    542545                                        if( moduleCriteria && moduleCriteria.size() > 0 ) {
    543                                                 def callUrl = moduleCriteriaUrl( module, entities, moduleCriteria );
     546                                                def callUrl = moduleCriteriaUrl( module );
     547                                                def callArgs = moduleCriteriaArguments( module, entities, moduleCriteria );
    544548                                               
    545549                                                try {
    546                                                         def json = moduleCommunicationService.callModuleRestMethodJSON( module.url, callUrl );
     550                                                        def json = moduleCommunicationService.callModuleMethod( module.url, callUrl, callArgs, "POST" );
    547551                                                        Closure checkClosure = moduleCriterionClosure( json );
    548552                                                       
     
    551555                                                       
    552556                                                } catch( Exception e ) {
    553                                                         log.error( "Error while retrieving data from " + module.name + ": " + e.getMessage() )
     557                                                        //log.error( "Error while retrieving data from " + module.name + ": " + e.getMessage() )
     558                                                        e.printStackTrace()
     559                                                        throw e
    554560                                                }
    555561                                        }
     
    608614        }
    609615       
    610         protected String moduleCriteriaUrl( module, entities, moduleCriteria ) {
     616        protected String moduleCriteriaUrl( module ) {
     617                def callUrl = module.url + '/rest/getQueryableFieldData'
     618                return callUrl;
     619        }
     620       
     621        protected String moduleCriteriaArguments( module, entities, moduleCriteria ) {
    611622                // Retrieve the data from the module
    612623                def tokens = entities.collect { it.giveUUID() }.unique();
    613624                def fields = moduleCriteria.collect { it.field }.unique();
    614625       
    615                 def callUrl = module.url + '/rest/getQueryableFieldData?entity=' + this.entity
     626                def callUrl = 'entity=' + this.entity
    616627                tokens.sort().each { callUrl += "&tokens=" + it.encodeAsURL() }
    617628                fields.sort().each { callUrl += "&fields=" + it.encodeAsURL() }
Note: See TracChangeset for help on using the changeset viewer.