Changeset 6678 for TI01-discovery-API


Ignore:
Timestamp:
05/03/10 12:23:08 (9 years ago)
Author:
mnagni
Message:

Updated the artifact version to 1.1.0
Refactored the logger (see the new NdgLogger?)
Implemented a new logic for the TermSearch? operator
Implemented the log to the searchLogDB
Completely removed the manual configuration (load driver, user, password, etc...) of the DataSources?

Location:
TI01-discovery-API/trunk/MEDINDiscoveryService
Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed
  • TI01-discovery-API/trunk/MEDINDiscoveryService/pom.xml

    r6667 r6678  
    44        <groupId>ndg.services.discovery</groupId> 
    55        <artifactId>MedinDiscoveryService</artifactId> 
    6         <version>1.0.0</version> 
     6        <version>1.1.0</version> 
    77        <packaging>aar</packaging> 
    88 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/common/NdgDictionary.java

    r6666 r6678  
    77 * */ 
    88public class NdgDictionary { 
    9  
    109        /** The name of the global configuration file*/ 
    1110        public final static String DEFAULT_PROPERTIES_FILENAME = "service.properties"; 
     
    1413        public final static String RESOURCE_BUNDLE = "ndg.common.messages";      
    1514         
    16         /** JNDI connection */ 
     15        /** JNDI Discovery connection */ 
    1716        public final static String DISCOVERY_DB_JNDI = "jndi.discoveryDB"; 
    18  
    19         /** The parameters related to a manual datasource connection */ 
    20         @Deprecated 
    21         public final static String JDBC_URI = "jdbc.uri"; 
    22         @Deprecated 
    23         public final static String JDBC_PSW = "jdbc.password"; 
    24         @Deprecated 
    25         public final static String JDBC_USERNAME = "jdbc.username"; 
    26         @Deprecated 
    27         public final static String JDBC_DRIVER = "jdbc.driver"; 
    2817         
    29  
    30  
     18        /** JNDI searchLog connection */ 
     19        public final static String SEARCH_LOG_DB_JNDI = "jndi.searchLogDB"; 
    3120} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/common/db/NdgBasicDataSource.java

    r6664 r6678  
    33import java.sql.Connection; 
    44import java.sql.SQLException; 
     5import java.util.Map; 
     6import java.util.WeakHashMap; 
    57 
    68import javax.naming.InitialContext; 
     
    810import javax.sql.DataSource; 
    911 
    10 import ndg.common.NdgDictionary; 
    1112import ndg.common.NdgMessage; 
    1213import ndg.common.exception.ResourceNotAvailable; 
    13  
    14 import org.apache.commons.dbcp.BasicDataSource; 
    15  
    1614 
    1715/** 
     
    2220public class NdgBasicDataSource { 
    2321 
    24         private String jndiDataSource; 
    25         private DataSource dataSource = null; 
    26         @Override 
    27         /** 
    28          * Assures that the connection to the data source is closed 
    29          **/ 
    30         protected void finalize() throws Throwable { 
    31                 shutdownDataSource(this.getDataSource()); 
    32                 super.finalize(); 
    33         } 
     22        private Map<String, DataSource> dsMap = new WeakHashMap<String, DataSource>(); 
    3423 
    35          
    36         /** 
    37          * Manually creates a <code>DataSource</code> using an Apache Commons-dbcp connction pool. 
    38          * 
    39          * @param connectURI the connection URI 
    40          * @param driver the name of the driver class to use 
    41          * @param username the name of the user to be used to open a connection 
    42          * @param password the username password  
    43          * @exception ResourceNotAvailable if the resource is not available 
    44          **/ 
    45         @Deprecated      
    46         public NdgBasicDataSource(String connectURI, String driver, 
    47                         String username, String password) throws ResourceNotAvailable { 
    48                 setupDataSource(connectURI, driver,     username, password); 
    49                 testConnection(); 
    50         }                
    51          
    52         /** 
    53          * Creates a <code>DataSource</code> using a JNDI resource. 
    54          *  
    55          * @param jndiDataSource the name of the resource which has to be looked up 
    56          * @exception ResourceNotAvailable if the resource is not available 
    57          **/ 
    58         public NdgBasicDataSource(String jndiDataSource) throws ResourceNotAvailable { 
    59                 this.jndiDataSource = jndiDataSource; 
    60                 lookupDataSource(); 
    61                 testConnection(); 
    62         }        
    63          
    64         public Connection getConnection() throws ResourceNotAvailable { 
     24        public Connection getConnection(String jndiDataSource) throws ResourceNotAvailable { 
    6525                try { 
    66                         return getDataSource().getConnection(); 
     26                        return getConnFromDS(jndiDataSource); 
    6727                } catch (SQLException e) { 
    6828                        throw new ResourceNotAvailable(e); 
     
    7030        } 
    7131 
    72         private DataSource getDataSource() throws ResourceNotAvailable { 
    73                 if (dataSource == null) { 
    74                         throw new ResourceNotAvailable( 
    75                                         new NdgMessage("config.not.loaded.error",  
    76                                                         new Object[]{NdgDictionary.DEFAULT_PROPERTIES_FILENAME}, null)); 
    77                 } 
    78                 return dataSource; 
     32        private Connection getConnFromDS(String jndiDataSource)  
     33                        throws ResourceNotAvailable, SQLException { 
     34                if (!dsMap.containsKey(jndiDataSource))  
     35                        lookupDataSource(jndiDataSource); 
     36                 
     37                if (dsMap.containsKey(jndiDataSource) && dsMap.get(jndiDataSource) != null) 
     38                                return dsMap.get(jndiDataSource).getConnection(); 
     39                return null; 
    7940        } 
    8041 
    81         private void setupDataSource(String connectURI, String driver, 
    82                         String username, String password) throws ResourceNotAvailable { 
    83                 BasicDataSource ds = new BasicDataSource(); 
    84                 ds.setDriverClassName(driver); 
    85                 ds.setUsername(username); 
    86                 ds.setPassword(password); 
    87                 ds.setUrl(connectURI); 
    88                 dataSource = ds; 
    89  
    90         } 
    91          
    92         private void shutdownDataSource(DataSource ds) throws SQLException { 
    93                 BasicDataSource bds = (BasicDataSource) ds; 
    94                 bds.close(); 
    95         }        
    96          
    97         private void lookupDataSource() throws ResourceNotAvailable { 
     42        private void lookupDataSource(String jndiDataSource) throws ResourceNotAvailable { 
    9843                InitialContext cxt; 
    99                  
     44                DataSource ds = null; 
    10045                try { 
    10146                        cxt = new InitialContext(); 
    10247                } catch (NamingException e) { 
    103                         throw new ResourceNotAvailable( 
    104                                         new NdgMessage("context.not.available",  
    105                                                         new Object[]{}, null), e); 
     48                        throw new ResourceNotAvailable(new NdgMessage("context.not.available", new Object[] {}, null), e); 
    10649 
    10750                } 
    108                  
    109                 if ( cxt == null ) { 
    110                         throw new ResourceNotAvailable( 
    111                                         new NdgMessage("context.not.available",  
    112                                                         new Object[]{}, null)); 
     51 
     52                if (cxt == null) { 
     53                        throw new ResourceNotAvailable(new NdgMessage("context.not.available", new Object[] {}, null)); 
    11354                } 
    11455 
    11556                try { 
    116                         dataSource = (DataSource) cxt.lookup( jndiDataSource ); 
     57                        ds = (DataSource) cxt.lookup(jndiDataSource); 
    11758                } catch (NamingException e) { 
    118                         // TODO Auto-generated catch block 
    119                         e.printStackTrace(); 
     59 
    12060                } 
    12161 
    122                 if ( dataSource == null ) { 
    123                         throw new ResourceNotAvailable( 
    124                                         new NdgMessage("datasource.not.available",  
    125                                                         new Object[]{jndiDataSource}, null)); 
     62                if (ds == null) { 
     63                        throw new ResourceNotAvailable(new NdgMessage("datasource.not.available", new Object[] { jndiDataSource }, 
     64                                        null)); 
    12665                } 
     66                dsMap.put(jndiDataSource, ds); 
    12767        } 
    128          
     68 
    12969        /** 
    13070         * Opens and close a connection to test the availability of the resource. 
    13171         *  
    132          * @exception ResourceNotAvailable if is not possible to open a <code>Connection</code> 
     72         * @exception ResourceNotAvailable 
     73         *                if is not possible to open a <code>Connection</code> 
    13374         **/ 
    134         private void testConnection() throws ResourceNotAvailable { 
     75        private void testConnection(String jndiDataSource) throws ResourceNotAvailable { 
    13576                try { 
    136                         Connection conn = getConnection(); 
     77                        Connection conn = getConnection(jndiDataSource); 
    13778                        conn.close(); 
    13879                } catch (SQLException e) { 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/DiscoveryServiceMEDINSkeleton.java

    r6666 r6678  
    33import java.beans.PropertyDescriptor; 
    44import java.lang.reflect.InvocationTargetException; 
     5import java.sql.Connection; 
     6import java.sql.PreparedStatement; 
     7import java.sql.SQLException; 
     8import java.sql.Timestamp; 
    59import java.util.ArrayList; 
     10import java.util.Calendar; 
    611import java.util.List; 
    712 
    8 import ndg.common.MessageFormatter; 
     13import ndg.common.NdgLogger; 
    914import ndg.common.NdgMessage; 
    1015import ndg.common.exception.NdgSQLException; 
     
    3944import ndg.services.discovery.medin.schema.SearchType; 
    4045import ndg.services.discovery.medin.schema.SimpleDocument1; 
     46import ndg.services.discovery.medin.schema.TermSearchType; 
     47import ndg.services.discovery.medin.schema.SearchType.SearchCriteria; 
    4148import ndg.services.discovery.model.PresentAgent; 
    4249import ndg.services.discovery.model.SearchAgent; 
    4350import ndg.services.jpa.OriginalDocument; 
    4451 
    45 import org.apache.log4j.Logger; 
    46  
    47  
    48  
     52import org.apache.axis2.context.MessageContext; 
     53import org.apache.log4j.Level; 
    4954 
    5055/** 
     
    5560public class DiscoveryServiceMEDINSkeleton implements DiscoveryServiceMEDINSkeletonInterface { 
    5661 
    57         private static Logger logger = Logger.getLogger(DiscoveryServiceMEDINSkeleton.class.getName()); 
    58  
    59         // NOTE - when specifying text relevance ranking further parsing is required 
    60         // whether its a full text search 
    61         // or using author or parameter ranking methods! 
    62         public static final String TEXTRELEVANCE_ORDERBYFIELD = "TextRelevance"; 
    63         public static final String DATASETSTARTDATE_ORDERBYFIELD = "DatasetStartDate"; 
    64         public static final String DATASETENDDATE_ORDERBYFIELD = "DatasetEndDate"; 
    65         public static final String DATACEENTRE_ORDERBYFIELD = "DataCentre"; 
    66         public static final String DATASETRESULTSETPOPULARITY_ORDERBYFIELD = "DatasetResultsetPopularity"; 
    67         public static final String PROXIMITY_ORDERBYFIELD = "Proximity"; 
    68         public static final String PROXIMITYNEARMISS_ORDERBYFIELD = "ProximityNearMiss"; 
    69         public static final String DATASETUPDATEORDER_ORDERBYFIELD = "DatasetUpdateOrder"; 
    70         public static final String DATASETORDER_ORDERBYFIELD = "DatasetOrder"; 
    71         public static final String DISCOVERYINGESTDATE_ORDERBYFIELD = "DiscoveryIngestDate"; 
    72         public static final String MEDINTERMTARGET1_ORDERBYFIELD = "MEDINTermTarget.1"; 
    73  
    74         // Other constants 
    75  
    76         public static final String DELIMITER = "-------------------------------------"; 
    77  
    78         // to_tsvector ignores the '_' character; as a work around replace this with 
    79         // the following string 
    80         // - primarily for use in the scope field 
    81         public static final String UNDERSCORE_REPLACEMENT = "UNDERSCORE"; 
    82  
    83         public static final String INVALID_LIST_NAME_MESSAGE = "Invalid list name: please use getListNames to get the valid list names"; 
     62        private static String insLogSQL = "INSERT INTO discoverySearchLogging(search_term, date_of_search, scope, originator_IP, number_results_returned) values (?,?,?,?,?)"; 
     63 
     64        private NdgLogger logHelper = DiscoveryBasic.getInstance().getNdgInstance(DiscoveryServiceMEDINSkeleton.class.getName()); 
    8465 
    8566        /** 
     
    8768         * use as input to the getList service 
    8869         *  
    89          * @param ndg.services.discovery.medin.generated 
    90          *            .GetListNamesDocument containing request 
    91          * @return ndg.services.discovery.medin.generated.GetListNamesReturnDocument containing result 
     70         * @param ndg 
     71         *            .services.discovery.medin.generated .GetListNamesDocument 
     72         *            containing request 
     73         * @return ndg.services.discovery.medin.generated.GetListNamesReturnDocument 
     74         *         containing result 
    9275         */ 
    93         public GetListNamesReturnDocument getListNames( 
    94                         GetListNamesDocument getListNames) { 
     76        public GetListNamesReturnDocument getListNames(GetListNamesDocument getListNames) { 
    9577                /*--- Generated by WSDL2Code, DO NOT TOUCH ---*/ 
    96                 GetListNamesReturnDocument response = GetListNamesReturnDocument.Factory 
    97                                 .newInstance(); 
     78                GetListNamesReturnDocument response = GetListNamesReturnDocument.Factory.newInstance(); 
    9879                GetListNamesReturnType responseContent = response.addNewGetListNamesReturn(); 
    9980                GetListNamesReturnType.ListNames listNames = responseContent.addNewListNames(); 
    10081                /*--- Generated by WSDL2Code, DO NOT TOUCH ---*/ 
    10182 
    102                 if (logger.isInfoEnabled()) { 
    103                         logger.info("getListNames() invoked"); 
    104                 } 
    105  
     83                logHelper.logMessage("getListNames() invoked", Level.DEBUG); 
    10684                for (DiscoveryDictionary.Names item : DiscoveryDictionary.Names.values()) { 
    10785                        listNames.addListName(item.fieldLabel()); 
    10886                } 
    109  
    110                 if (logger.isInfoEnabled()) { 
    111                         logger.info("getListNames() completed successfully"); 
    112                 } 
     87                logHelper.logMessage("getListNames() completed successfully", Level.DEBUG); 
    11388                return response; 
    11489 
     
    125100                DoSearchReturnDocument response = DoSearchReturnDocument.Factory.newInstance(); 
    126101                SearchReturnType responseContent = response.addNewDoSearchReturn(); 
    127                  
    128                 SearchAgent agent = new SearchAgent(doSearch.getDoSearch());     
    129                 boolean status = false;          
     102 
     103                SearchAgent agent = new SearchAgent(doSearch.getDoSearch()); 
     104                boolean status = false; 
    130105                String statusMessage = null; 
    131106                try { 
    132107                        List<OriginalDocument> result = agent.doSearch(); 
    133108                        SearchType st = doSearch.getDoSearch(); 
    134                          
     109 
    135110                        RetrieveCriteriaType rct = st.getRetrieveCriteria(); 
    136111                        DiscoveryDictionary.RecordDetail type = DiscoveryDictionary.getRecordDetails(null); 
     
    139114                                type = DiscoveryDictionary.getRecordDetails(rct.getRecordDetail()); 
    140115                                orderBy = rct.getOrderByArray(); 
    141                         }                                                        
    142                          
     116                        } 
     117 
    143118                        processResult(result, responseContent.addNewDocuments(), type, orderBy); 
    144119                        status = (result != null && result.size() > 0 ? true : false); 
    145120                } catch (NdgSQLException e) { 
    146                                 logger.error(e.getMessage(), e); 
     121                        logHelper.logMessage(e.getMessage(), Level.ERROR, e); 
    147122                        statusMessage = e.getMessage(); 
    148                 } catch (ResourceNotAvailable e) {                               
    149                                 logger.error(e.getMessage(), e); 
     123                } catch (ResourceNotAvailable e) { 
     124                        logHelper.logMessage(e.getMessage(), Level.ERROR, e); 
    150125                        statusMessage = e.getMessage(); 
    151126                } finally { 
     
    154129                                NdgMessage msg = null; 
    155130                                if (responseContent.getHits() > 0) { 
    156                                         msg = new NdgMessage("search.successful", new Object[] {});      
     131                                        msg = new NdgMessage("search.successful", new Object[] {}); 
    157132                                } else { 
    158133                                        msg = new NdgMessage("search.no.results", new Object[] {}); 
    159134                                } 
    160135                                statusMessage = DiscoveryBasic.getInstance().getFormatter().getFormattedText(msg); 
    161                         }                        
     136                        } 
    162137                        responseContent.setStatus(status); 
    163138                        responseContent.setStatusMessage(statusMessage); 
    164139                        responseContent.setResultId(0); // not used at the moment 
    165                 }                
    166                 return response;         
     140                } 
     141                logClientIP(responseContent, doSearch); 
     142                return response; 
    167143        } 
    168144 
     
    180156                PresentAgent agent = new PresentAgent(); 
    181157                List<String> documentsId = new ArrayList<String>(); 
    182                 try {                    
     158                try { 
    183159                        for (SimpleDocument1 doc : doPresent.getDoPresent().getDocumentsArray()) { 
    184160                                documentsId.add(doc.getDocumentId()); 
     
    189165                        DiscoveryDictionary.RecordDetail detail = DiscoveryDictionary.getRecordDetails(recDetail); 
    190166                        processResult(result, responseContent.addNewDocuments(), detail, null); 
    191                         status = (result != null && result.size() >      0 ? true : false); 
     167                        status = (result != null && result.size() > 0 ? true : false); 
    192168                } catch (NdgSQLException e) { 
    193169                        statusMessage = e.getMessage(); 
     
    198174                                NdgMessage msg = new NdgMessage("present.successful", new Object[] {}); 
    199175                                statusMessage = DiscoveryBasic.getInstance().getFormatter().getFormattedText(msg); 
    200                         }  
     176                        } 
    201177                        responseContent.setStatus(status); 
    202178                        responseContent.setStatusMessage(statusMessage); 
    203179                } 
    204                  
     180 
    205181                return response; 
    206182        } 
     
    209185         * Performs the getList operation 
    210186         *  
    211          * @param ndg.services.discovery.medin.generated 
    212          *            .GetListDocument containing request 
    213          * @return ndg.services.discovery.medin.generated.GetListReturnDocument containing result 
     187         * @param ndg 
     188         *            .services.discovery.medin.generated .GetListDocument 
     189         *            containing request 
     190         * @return ndg.services.discovery.medin.generated.GetListReturnDocument 
     191         *         containing result 
    214192         * @throws DiscoveryWSException 
    215193         */ 
    216194        public GetListReturnDocument getList(GetListDocument request) { 
    217                 logger.info("getList() invoked"); 
    218                 GetListReturnDocument response = GetListReturnDocument.Factory 
    219                                 .newInstance(); 
     195                logHelper.logMessage("getList() invoked", Level.DEBUG); 
     196                GetListReturnDocument response = GetListReturnDocument.Factory.newInstance(); 
    220197                GetListReturnType responseContent = response.addNewGetListReturn(); 
    221198                GetListReturnType.List list = responseContent.addNewList(); 
     
    223200                // parse the request message 
    224201                GetListType requestContent = request.getGetList(); 
    225                  
     202 
    226203                String name = requestContent.getListName().trim(); 
    227204                list.setName(name); 
    228205 
    229206                DiscoveryDictionary.Names listName = DiscoveryDictionary.getNames(name); 
    230                  
     207 
    231208                if (listName == null) 
    232209                        return response; 
    233                  
     210 
    234211                if (listName.equals(DiscoveryDictionary.Names.TermTarget)) { 
    235212                        for (DiscoveryDictionary.TermTarget item : DiscoveryDictionary.TermTarget.values()) { 
     
    269246                        } 
    270247                } else { 
    271                         logger.warn(INVALID_LIST_NAME_MESSAGE); 
    272                         // throw new DiscoveryWSException(INVALID_LIST_NAME_MESSAGE); 
    273                 } 
    274  
    275                 logger.info("getList() completed successfully"); 
     248                        logHelper.logMessage("invalid.list.name", Level.WARN); 
     249                } 
     250                logHelper.logMessage("getList() completed successfully", Level.DEBUG); 
    276251                return response; 
    277252        } 
     
    348323         */ 
    349324 
    350         private void processResult(List<OriginalDocument> results, Documents documents, RecordDetail type, OrderByType[] orderBy) { 
     325        private void processResult(List<OriginalDocument> results, Documents documents, RecordDetail type, 
     326                        OrderByType[] orderBy) { 
    351327                if (results != null && results.size() == 0) 
    352328                        return; 
     
    359335                        } 
    360336 
    361                         /* -- Please note that the following IF do not own a continue  
    362                          * statement in order to execute the final 'fillOrderedField' -- */ 
    363                         if (type.equals(DiscoveryDictionary.RecordDetail.DocumentFull)) {                                
    364                                 ReturnFullType fullType = documents.addNewDocumentFull();        
     337                        /* 
     338                         * -- Please note that the following IF do not own a continue 
     339                         * statement in order to execute the final 'fillOrderedField' -- 
     340                         */ 
     341                        if (type.equals(DiscoveryDictionary.RecordDetail.DocumentFull)) { 
     342                                ReturnFullType fullType = documents.addNewDocumentFull(); 
    365343                                fillDocument(fullType, result); 
    366344                                documentType = fullType; 
     
    369347                                ReturnSummaryType summaryType = documents.addNewDocumentSummary(); 
    370348                                fillDocument(summaryType, result); 
    371                                 documentType = summaryType;                              
     349                                documentType = summaryType; 
    372350                        } 
    373351                        if (type.equals(DiscoveryDictionary.RecordDetail.DocumentBrief)) { 
    374352                                ReturnBriefType briefType = documents.addNewDocumentBrief(); 
    375353                                fillDocument(briefType, result); 
    376                                 documentType = briefType;                                
    377                         } 
    378                         if (orderBy != null)  
     354                                documentType = briefType; 
     355                        } 
     356                        if (orderBy != null) 
    379357                                fillOrderedFieldArray(documentType, orderBy, result); 
    380358                } 
    381359        } 
    382          
    383          
    384          
    385         /** 
    386          * Fills the <code>OrderedFieldArray[]</code> in the given <code>documentType</code> with  
    387          * the proper values from the documents retrieved after the query. 
    388          * Obviously if the user request included the request to sort by some field.  
     360 
     361        /** 
     362         * Fills the <code>OrderedFieldArray[]</code> in the given 
     363         * <code>documentType</code> with the proper values from the documents 
     364         * retrieved after the query. Obviously if the user request included the 
     365         * request to sort by some field. 
    389366         **/ 
    390367        private <T> void fillOrderedFieldArray(T documentType, OrderByType[] orders, OriginalDocument result) { 
     
    399376                        String value = "DataError"; 
    400377                        NdgMessage msg = new NdgMessage("invocation.error", new Object[] { "Field.get(result)" }); 
    401                         MessageFormatter formatter = DiscoveryBasic.getInstance().getFormatter(); 
    402378                        try { 
    403379                                PropertyDescriptor field = DiscoveryDictionary.getOriginalDocumentProperty(order.getOdField()); 
     
    406382                                newOMT.setMetricValue(value); 
    407383                        } catch (IllegalArgumentException e) { 
    408                                 logger.error(formatter.getFormattedText(msg), e); 
     384                                logHelper.logMessage(msg, Level.ERROR, e); 
    409385                        } catch (IllegalAccessException e) { 
    410                                 logger.error(formatter.getFormattedText(msg), e); 
     386                                logHelper.logMessage(msg, Level.ERROR, e); 
    411387                        } catch (InvocationTargetException e) { 
    412                                 logger.error(formatter.getFormattedText(msg), e); 
    413                         } 
    414                 } 
    415         } 
    416          
    417          
    418          
    419         /** 
    420          * Creates in the given <code>documentType</code>, and returns it,  
    421          * a new {@link OrderingMetricType} 
    422          **/     
    423         private OrderingMetricType getNewOMT(Object documentType){ 
     388                                logHelper.logMessage(msg, Level.ERROR, e); 
     389                        } 
     390                } 
     391        } 
     392 
     393        /** 
     394         * Creates in the given <code>documentType</code>, and returns it, a new 
     395         * {@link OrderingMetricType} 
     396         **/ 
     397        private OrderingMetricType getNewOMT(Object documentType) { 
    424398                OrderingMetricType ret = null; 
    425                 if (ReturnSimpleType.class.isAssignableFrom(documentType.getClass())){ 
     399                if (ReturnSimpleType.class.isAssignableFrom(documentType.getClass())) { 
    426400                        ret = null; 
    427                 }                
    428                 if (ReturnFullType.class.isAssignableFrom(documentType.getClass())){ 
    429                         ReturnFullType tmp = (ReturnFullType)documentType; 
     401                } 
     402                if (ReturnFullType.class.isAssignableFrom(documentType.getClass())) { 
     403                        ReturnFullType tmp = (ReturnFullType) documentType; 
    430404                        ret = tmp.addNewOrderedField(); 
    431405                } 
    432                 if (ReturnBriefType.class.isAssignableFrom(documentType.getClass())){ 
    433                         ReturnBriefType tmp = (ReturnBriefType)documentType; 
     406                if (ReturnBriefType.class.isAssignableFrom(documentType.getClass())) { 
     407                        ReturnBriefType tmp = (ReturnBriefType) documentType; 
    434408                        ret = tmp.addNewOrderedField(); 
    435409                } 
    436                 if (ReturnSummaryType.class.isAssignableFrom(documentType.getClass())){ 
    437                         ReturnSummaryType tmp = (ReturnSummaryType)documentType; 
     410                if (ReturnSummaryType.class.isAssignableFrom(documentType.getClass())) { 
     411                        ReturnSummaryType tmp = (ReturnSummaryType) documentType; 
    438412                        ret = tmp.addNewOrderedField(); 
    439413                } 
    440414                return ret; 
    441415        } 
    442                  
     416 
    443417        private void fillCustomInfo(CustomInfo info, OriginalDocument result) { 
    444418                info.setAuthors(result.getAuthors() != null ? result.getAuthors() : ""); 
     
    447421                info.setLineage(result.getLineage() != null ? result.getLineage() : ""); 
    448422                info.setParameters(result.getParameters() != null ? result.getParameters() : ""); 
    449                 info.setLimitationsPublicAccess(result.getLimitationsPublicAccess() != null ? result.getLimitationsPublicAccess() : ""); 
     423                info.setLimitationsPublicAccess(result.getLimitationsPublicAccess() != null ? result 
     424                                .getLimitationsPublicAccess() : ""); 
    450425                info.setResourceType(result.getResourceType() != null ? result.getResourceType() : ""); 
    451426                info.setTopicCategory(result.getTopicCategory() != null ? result.getTopicCategory() : ""); 
    452427        } 
    453          
    454         private void fillDocument(ReturnFullType type, OriginalDocument result){                         
     428 
     429        private void fillDocument(ReturnFullType type, OriginalDocument result) { 
    455430                type.setDocumentId(result.getOriginalDocumentFilename()); 
    456431                type.setTitle(result.getDatasetName()); 
     
    460435                fillCustomInfo(info, result); 
    461436        } 
    462          
    463         private void fillDocument(ReturnSummaryType type, OriginalDocument result){                      
     437 
     438        private void fillDocument(ReturnSummaryType type, OriginalDocument result) { 
    464439                type.setDocumentId(result.getOriginalDocumentFilename()); 
    465440                type.setTitle(result.getDatasetName()); 
    466441                type.setAbstract(result.getDatasetAbstract()); 
    467442        } 
    468          
    469         private void fillDocument(ReturnBriefType type, OriginalDocument result){                        
     443 
     444        private void fillDocument(ReturnBriefType type, OriginalDocument result) { 
    470445                type.setDocumentId(result.getOriginalDocumentFilename()); 
    471446                type.setTitle(result.getDatasetName()); 
     
    473448                fillCustomInfo(info, result); 
    474449        } 
    475          
    476         private void fillDocument(ReturnSimpleType type, OriginalDocument result){                       
     450 
     451        private void fillDocument(ReturnSimpleType type, OriginalDocument result) { 
    477452                type.setDocumentId(result.getOriginalDocumentFilename()); 
    478453        } 
     454 
     455        private void logClientIP(SearchReturnType responseContent, DoSearchDocument doSearch) { 
     456                String ipAddress = ""; 
     457                MessageContext messageContext = MessageContext.getCurrentMessageContext(); 
     458                if (messageContext != null) { 
     459                        ipAddress = (String) messageContext.getProperty(MessageContext.REMOTE_ADDR); 
     460                } 
     461                try { 
     462                        insertInLogDB(doSearch, responseContent, ipAddress); 
     463                } catch (ResourceNotAvailable e) { 
     464                        // TODO Auto-generated catch block 
     465                        e.printStackTrace(); 
     466                } catch (SQLException e) { 
     467                        // TODO Auto-generated catch block 
     468                        e.printStackTrace(); 
     469                } 
     470                NdgMessage msg = new NdgMessage("client.ip", new Object[] { ipAddress }); 
     471                logHelper.logMessage(msg, Level.INFO); 
     472        } 
     473 
     474        private void insertInLogDB(DoSearchDocument doSearch, SearchReturnType responseContent, String clientIP) 
     475                        throws SQLException, ResourceNotAvailable { 
     476                Connection conn = DiscoveryBasic.getInstance().getLogConnection(); 
     477                PreparedStatement stat = conn.prepareStatement(insLogSQL); 
     478                String termSearch = doSearch.getDoSearch() != null  
     479                                ? assembleTermSearch(doSearch.getDoSearch().getSearchCriteria())  
     480                                                : null; 
     481                stat.setString(1, termSearch); 
     482                stat.setTimestamp(2, new Timestamp(Calendar.getInstance().getTimeInMillis())); 
     483                String scope = doSearch.getDoSearch() != null  
     484                        ? getScope(doSearch.getDoSearch().getScopeArray())  
     485                                        : null; 
     486                stat.setString(3, scope); 
     487                stat.setString(4, clientIP); 
     488                stat.setInt(5, responseContent.getHits()); 
     489                stat.executeUpdate(); 
     490        } 
     491 
     492        private String getScope(String[] scopes) { 
     493                StringBuffer sb = new StringBuffer(); 
     494                for (String item : scopes) { 
     495                        sb.append(item); 
     496                        sb.append(", "); 
     497                } 
     498                if (sb.length() > 0) 
     499                        sb.delete(sb.length() - 2, sb.length()); 
     500                return sb.toString(); 
     501        } 
     502 
     503        private String assembleTermSearch(SearchCriteria criteria) { 
     504                StringBuffer sb = new StringBuffer(); 
     505                for (TermSearchType ts : criteria.getTermSearchArray()) { 
     506                        sb.append(ts.getTerm()); 
     507                        sb.append(", "); 
     508                } 
     509                if (sb.length() > 0) 
     510                        sb.delete(sb.length() - 2, sb.length()); 
     511                return sb.toString(); 
     512        } 
    479513} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/medin/DiscoveryBasic.java

    r6599 r6678  
    1010import ndg.common.MessageFormatter; 
    1111import ndg.common.NdgDictionary; 
     12import ndg.common.NdgLogger; 
    1213import ndg.common.NdgMessage; 
    1314import ndg.common.db.NdgBasicDataSource; 
     
    2526 
    2627        /** The database connection */ 
    27         private NdgBasicDataSource dataSource; 
     28        private final NdgBasicDataSource dataSource = new NdgBasicDataSource(); 
    2829 
    2930        /** The properties defining the service */ 
     
    4344 
    4445        /** 
     46         * Returns a connection to the underlying Discovery datasource 
     47         *  
     48         * @return a <code>Connection</code> instance 
     49         * @exception NdgException 
     50         *                if <code>Connection</code> is not available 
     51         * */ 
     52        public final Connection getDiscoveryConnection() throws ResourceNotAvailable { 
     53                return getConnection(NdgDictionary.DISCOVERY_DB_JNDI); 
     54        } 
     55         
     56        /** 
     57         * Returns a connection to the underlying logDB datasource 
     58         *  
     59         * @return a <code>Connection</code> instance 
     60         * @exception NdgException 
     61         *                if <code>Connection</code> is not available 
     62         * */ 
     63        public final Connection getLogConnection() throws ResourceNotAvailable { 
     64                return getConnection(NdgDictionary.SEARCH_LOG_DB_JNDI); 
     65        }        
     66         
     67        /** 
    4568         * Returns a connection to the underlying datasource 
    4669         *  
     
    4972         *                if <code>Connection</code> is not available 
    5073         * */ 
    51         public final Connection getConnection() throws ResourceNotAvailable { 
    52                 if (dataSource == null) { 
    53                         getDataSource(); 
    54                 } 
    55                 return dataSource.getConnection(); 
     74        private final Connection getConnection(String jndi_connection) throws ResourceNotAvailable { 
     75                return dataSource.getConnection(getConfigurationProperties().getProperty(jndi_connection)); 
    5676        } 
    5777 
     
    6585        } 
    6686 
    67         /** Return a MARIN specific {@link MessageFormatter} instance */ 
     87        /** Return a MEDIN specific {@link NdgLogger} instance */ 
     88        public final NdgLogger getNdgInstance(String nameLogger) { 
     89                if (formatter == null) { 
     90                        formatter = new MessageFormatter(getMessagetResourceBundle()); 
     91                } 
     92                return new NdgLogger(nameLogger, getFormatter()); 
     93        } 
     94         
     95        /**  
     96         * Return a MEDIN specific {@link MessageFormatter} instance 
     97         **/     
    6898        public final MessageFormatter getFormatter() { 
    6999                if (formatter == null) { 
     
    71101                } 
    72102                return formatter; 
    73         } 
    74  
     103        }        
     104         
    75105        /** 
    76106         * Returns the configuration properties 
     
    117147                } 
    118148        } 
    119  
    120         private NdgBasicDataSource getDataSource() throws ResourceNotAvailable { 
    121                 if (dataSource == null) { 
    122                         try { 
    123                                 if (getConfigurationProperties().containsKey(NdgDictionary.DISCOVERY_DB_JNDI)) { 
    124                                         dataSource = new NdgBasicDataSource(getConfigurationProperties().getProperty( 
    125                                                         NdgDictionary.DISCOVERY_DB_JNDI)); 
    126                                 } else { 
    127                                         tryManualConfiguration(); 
    128                                 } 
    129                         } catch (ResourceNotAvailable e) { 
    130                                 tryManualConfiguration(); 
    131                         }  
    132                 } 
    133                 return dataSource; 
    134         } 
    135          
    136         private void tryManualConfiguration() throws ResourceNotAvailable{ 
    137                 if (getConfigurationProperties().containsKey(NdgDictionary.JDBC_URI)) { 
    138                         dataSource = new NdgBasicDataSource(getConfigurationProperties().getProperty( 
    139                                         NdgDictionary.JDBC_URI), getConfigurationProperties().getProperty( 
    140                                         NdgDictionary.JDBC_DRIVER), getConfigurationProperties().getProperty( 
    141                                         NdgDictionary.JDBC_USERNAME), getConfigurationProperties().getProperty( 
    142                                         NdgDictionary.JDBC_PSW)); 
    143                 } 
    144         } 
    145149} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/CommonMethods.java

    r6659 r6678  
    88 
    99import ndg.common.MessageFormatter; 
     10import ndg.common.NdgLogger; 
    1011import ndg.common.NdgMessage; 
    1112import ndg.common.exception.NdgSQLException; 
     
    1718import ndg.services.discovery.medin.schema.SearchType.SearchCriteria; 
    1819 
    19 import org.apache.log4j.Logger; 
     20import org.apache.log4j.Level; 
    2021 
    2122public abstract class CommonMethods<T> { 
    2223         
    23         private static Logger logger = Logger.getLogger(CommonMethods.class.getName()); 
     24        private NdgLogger logHelper = DiscoveryBasic.getInstance().getNdgInstance(CommonMethods.class.getName()); 
    2425         
    2526        /** 
     
    107108                selectSQL.append(whereSQL); 
    108109 
    109                 if (logger.isInfoEnabled()) 
    110                         logger.info("SQL query generated: " + selectSQL); 
    111  
     110                logHelper.logMessage("SQL query generated: " + selectSQL, Level.INFO); 
    112111                return selectSQL.toString(); 
    113112        } 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/PresentAgent.java

    r6659 r6678  
    1010import java.util.List; 
    1111 
     12import ndg.common.NdgLogger; 
    1213import ndg.common.NdgMessage; 
    1314import ndg.common.exception.NdgSQLException; 
     
    2021import ndg.services.jpa.OriginalDocument; 
    2122 
    22 import org.apache.log4j.Logger; 
     23import org.apache.log4j.Level; 
    2324 
    2425/** 
     
    2728 * @author Maurizio Nagni <maurizio.nagni@stcf.ac.uk> 
    2829 **/ 
    29 public class PresentAgent extends CommonMethods { 
    30  
    31         private static Logger logger = Logger.getLogger(SearchAgent.class.getName()); 
     30public class PresentAgent extends CommonMethods<OriginalDocument> { 
     31 
     32        private NdgLogger logHelper = DiscoveryBasic.getInstance().getNdgInstance(SearchAgent.class.getName()); 
    3233 
    3334        private List<String> documentsId = new ArrayList<String>(); 
     
    4344                                                break; 
    4445                                } catch (SQLException e) { 
    45                                         logger.error(rs.toString(), e); 
     46                                        logHelper.logMessage(rs.toString(), Level.ERROR, e); 
    4647                                        break; 
    4748                                } 
     
    5051                                        ret.add(item); 
    5152                                } catch (SQLException e) { 
    52                                         logger.error(rs.toString(), e); 
     53                                        logHelper.logMessage(rs.toString(), Level.ERROR, e); 
    5354                                } 
    5455                        } 
     
    121122                whereSQL.append(DiscoveryDictionary.TRANSFORMED_DOCUMENT_TABLE); 
    122123                whereSQL.append(".transformed_format = '"); 
    123                 whereSQL.append(DiscoveryDictionary.getMetadataFormat(format).fieldName()); 
     124                whereSQL.append(docFormat.fieldName()); 
    124125                whereSQL.append("'"); 
    125126                checkWHERE_AND(whereSQL, false); 
     
    128129                whereSQL.append(DiscoveryDictionary.ORIGINAL_DOCUMENT_TABLE); 
    129130                whereSQL.append(".original_document_id"); 
    130         } 
    131          
    132         private void prepareOrderBy(StringBuffer whereSQL, StringBuffer sqlCmd, RetrieveCriteriaType criteria) { 
    133                 StringBuffer orderSQL = getOrderBy(criteria, sqlCmd); 
    134                 /* -- Append the ORDER BY clause to the WHERE command -- */ 
    135                 if (orderSQL.length() > 0) { 
    136                         whereSQL.append(" ORDER BY "); 
    137                         whereSQL.append(orderSQL); 
    138                 } 
    139131        } 
    140132 
     
    180172                                        } 
    181173                                } catch (IllegalArgumentException e) { 
    182                                         logger.error(msg, e); 
     174                                        logHelper.logMessage(msg, Level.ERROR, e); 
    183175                                } catch (IllegalAccessException e) { 
    184                                         logger.error(msg, e); 
     176                                        logHelper.logMessage(msg, Level.ERROR, e); 
    185177                                } catch (InvocationTargetException e) { 
    186                                         logger.error(msg, e); 
     178                                        logHelper.logMessage(msg, Level.ERROR, e); 
    187179                                } 
    188180                } 
     
    207199                this.documentsId = documentsId; 
    208200                String sqlQuery = assembleSearch(null, type); 
    209                 boolean commit = false; 
    210201                if (conn == null) { 
    211                         conn = DiscoveryBasic.getInstance().getConnection(); 
    212                         commit = true; 
     202                        conn = DiscoveryBasic.getInstance().getDiscoveryConnection(); 
    213203                } 
    214204                List<OriginalDocument> searchResult = executeSearch(conn, sqlQuery); 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/SearchAgent.java

    r6666 r6678  
    1212import java.util.List; 
    1313 
     14import ndg.common.NdgLogger; 
    1415import ndg.common.exception.NdgSQLException; 
    1516import ndg.common.exception.ResourceNotAvailable; 
     
    2829import ndg.services.jpa.OriginalDocument; 
    2930 
    30 import org.apache.log4j.Logger; 
     31import org.apache.log4j.Level; 
    3132 
    3233/** 
     
    3738 * @author Maurizio Nagni <maurizio.nagni@stcf.ac.uk> 
    3839 */ 
    39 public class SearchAgent extends CommonMethods { 
    40  
     40public class SearchAgent extends CommonMethods<String> { 
     41 
     42        private NdgLogger logHelper = DiscoveryBasic.getInstance().getNdgInstance(SearchAgent.class.getName()); 
     43         
    4144        private String updateCounterSQL = "UPDATE original_document SET resultset_count = ? WHERE original_document_filename = ?"; 
    4245        private String getValue = "SELECT resultset_count as counter from original_document"; 
    4346         
    44         private enum OPERATOR {AND, OR, NOT}; 
    45          
    46         private static Logger logger = Logger.getLogger(SearchAgent.class.getName()); 
     47        private enum OPERATOR {AND, OR, NOT, AND_NOT, OR_NOT}; 
    4748 
    4849        // how many results to display in result set 
     
    7475        public List<OriginalDocument> doSearch() throws NdgSQLException, ResourceNotAvailable { 
    7576                SearchCriteria criteria = searchType.getSearchCriteria(); 
    76                 Connection conn = DiscoveryBasic.getInstance().getConnection(); 
     77                Connection conn = DiscoveryBasic.getInstance().getDiscoveryConnection(); 
    7778                List<OriginalDocument> searchResult = null; 
    7879                boolean commit = false; 
     
    259260         */ 
    260261        private boolean isPOSIXWildcardSeach(String term) { 
    261                 logger.info("Checking for wildcards in search term"); 
     262                //logger.info("Checking for wildcards in search term"); 
    262263                for (int i = 0, is = term.length(); i < is; i++) { 
    263264                        char c = term.charAt(i); 
     
    276277                                // case '|': 
    277278                        case '\\': 
    278                                 logger.info("- found wildcards - treat as a regexp search"); 
     279                                //logger.info("- found wildcards - treat as a regexp search"); 
    279280                                return true; 
    280281                        default: 
     
    282283                        } 
    283284                } 
    284                 logger.info("- no wildcards found - treat at text search"); 
     285                //logger.info("- no wildcards found - treat at text search"); 
    285286                return false; 
    286         } 
    287  
    288         /** 
    289          * Prepare an INSERT sql statement to submit to Discovery DB to increment 
    290          * resultsetAccess count 
    291          *  
    292          * @param originalDocumentFilename 
    293          *            - String 
    294          * @param updatedCountVal 
    295          *            - Integer 
    296          * @return String : sql insert statement 
    297          */ 
    298         private static String updateResultSetQueryString(String originalDocumentFilename, Integer updatedCountVal) { 
    299  
    300                 // UPDATE original_document SET resultset_count = '1' WHERE 
    301                 // original_document_filename='badc.nerc.ac.uk__DIF__badc.nerc.ac.uk-DIF-dataent_11642968801511608.xml'; 
    302                 String statementStringBuild = "UPDATE original_document SET resultset_count = '" + updatedCountVal.toString() 
    303                                 + "' WHERE original_document_filename = '" + originalDocumentFilename + "';"; 
    304  
    305                 return statementStringBuild; 
    306287        } 
    307288 
     
    325306                                break; 
    326307 
    327                         if (logger.isDebugEnabled()) { 
    328                                 logger.debug("Search term: " + term); 
    329                                 logger.debug("Searct termTarget: " + termTarget.toString()); 
    330                         } 
     308                        logHelper.logMessage("Search term - TermTarget: " + term + " - " + termTarget, Level.DEBUG); 
    331309 
    332310                        /* -- Converts the query string in a postgresql proper format -- */ 
     
    342320                        fromSQL.append("') AS query" + Integer.toString(queryIndex)); 
    343321 
    344                         if (secondPass && queryIndex < term.length()) { 
    345                                 OPERATOR operator = getOperator(termType.getOperator()); 
    346                                 whereSQL.append(" "); 
     322                        OPERATOR operator = getOperator(termType.getOperator()); 
     323                         
     324                        if ((!secondPass && operator.equals(OPERATOR.NOT))  
     325                                        || (secondPass && queryIndex < term.length())) { 
     326                                whereSQL.append(" ");                            
    347327                                whereSQL.append(operator.name()); 
    348328                                whereSQL.append(" ");                            
     
    456436                        return; 
    457437 
     438                StringBuffer safeBuffer = new StringBuffer(); 
     439 
     440                boolean secondPass = false; 
     441                for (String scopeLabel : scopes) { 
     442                        DiscoveryDictionary.Scope scope = DiscoveryDictionary.getScope(scopeLabel); 
     443                        logHelper.logMessage("Scope: " + scope, Level.DEBUG); 
     444                        if (scope == null) 
     445                                continue; 
     446                        if (secondPass) 
     447                                whereSQL.append(" & "); 
     448                        fromSQL.append(" '" + scope.fieldName() + "' "); 
     449                        secondPass = true; 
     450                } 
     451 
     452                if (safeBuffer.length() == 0)  
     453                        return; 
     454                 
    458455                /* -- appends the terms (FROM part) -- */ 
    459456                checkFROMComma(fromSQL, false); 
    460457                fromSQL.append(" to_tsquery("); 
    461                 boolean secondPass = false; 
    462                 for (String scopeLabel : scopes) { 
    463                         DiscoveryDictionary.Scope scope = DiscoveryDictionary.getScope(scopeLabel); 
    464                         if (logger.isDebugEnabled()) { 
    465                                 logger.debug("Scope: " + scope); 
    466                         } 
    467                         if (secondPass) 
    468                                 whereSQL.append(" & "); 
    469                         fromSQL.append(" '" + scope.fieldName() + "' "); 
    470                 } 
    471                 fromSQL.append(") AS scopeQuery "); 
    472  
     458                fromSQL.append(safeBuffer.toString()); 
     459                fromSQL.append(") AS scopeQuery ");              
    473460                checkWHERE_AND(whereSQL, false); 
    474461                whereSQL.append(" scopeQuery @@ (scope_ts_vector) "); 
     
    516503         
    517504        private void updateCountVal(List<String> documentIDs) throws NdgSQLException, ResourceNotAvailable {             
    518                 Connection conn = DiscoveryBasic.getInstance().getConnection(); 
    519                 List<OriginalDocument> searchResult = null; 
     505                Connection conn = DiscoveryBasic.getInstance().getDiscoveryConnection(); 
    520506                boolean commit = false; 
    521507                try { 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/resources/ndg/common/messages.properties

    r6666 r6678  
    1010present.successful = Successful. 
    1111search.no.results = Search was successful but generated no results. 
     12client.ip = The client ip is {0} 
     13invalid.list.name = "Invalid list name: please use getListNames to get the valid list names"; 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/resources/service.properties

    r6659 r6678  
    33jndi.discoveryDB = java:/comp/env/jdbc/discoveryDB 
    44 
    5 # these property will be used to open a connection to the DB 
    6 # ONLY IF  
    7 # 1) jndi.discoveryDB is commented 
    8 # 2) the application fails to use jndi.discoveryDB  
    9 # In all the other cases these properties are simply not used 
    10 jdbc.uri = jdbc:postgresql://neptune.badc.rl.ac.uk:5432/discovery 
    11 jdbc.username = badc 
    12 jdbc.password = hwk298t 
    13 jdbc.driver = org.postgresql.Driver 
    14  
    15 jdbc.searchLoggingUri = jdbc:postgresql://proglue.badc.rl.ac.uk:5432/searchLog 
    16 jdbc.searchLoggingusername = badc 
    17 jdbc.searchLoggingpassword = k9WRa7rE 
     5jndi.searchLogDB = java:/comp/env/jdbc/searchLogDB 
    186 
    197namespace.DIF = http://gcmd.gsfc.nasa.gov/Aboutus/xml/dif/ 
Note: See TracChangeset for help on using the changeset viewer.