Changeset 6510 for TI01-discovery-API


Ignore:
Timestamp:
08/02/10 13:48:38 (10 years ago)
Author:
mnagni
Message:

Implemented a JNDI connection for the NdgBasicDataSource?
Updated the DiscoveryBasic? to try as first the JNDI connection and if fails the manual configuration.
Properly updated the Discovery message.properties
Added a could of new messages
Fixed a misunderstand in the SearchAgent?

Location:
TI01-discovery-API/trunk/MEDINDiscoveryService/src/main
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/common/db/NdgBasicDataSource.java

    r6465 r6510  
    44import java.sql.SQLException; 
    55 
     6import javax.naming.InitialContext; 
     7import javax.naming.NamingException; 
    68import javax.sql.DataSource; 
    79 
     
    2022public class NdgBasicDataSource { 
    2123 
     24        private String jndiDataSource; 
    2225        private DataSource dataSource = null; 
    2326         
     
    3134        } 
    3235 
     36         
     37        /** 
     38         * Manually creates a <code>DataSource</code> using an Apache Commons-dbcp connction pool. 
     39         * 
     40         * @param connectURI the connection URI 
     41         * @param driver the name of the driver class to use 
     42         * @param username the name of the user to be used to open a connection 
     43         * @param password the username password  
     44         * @exception ResourceNotAvailable if the resource is not available 
     45         **/ 
    3346        public NdgBasicDataSource(String connectURI, String driver, 
    34                         String username, String password) { 
    35                 dataSource = setupDataSource(connectURI, driver,        username, password); 
     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(); 
    3662        }        
    3763         
     
    5379        } 
    5480 
    55         private DataSource setupDataSource(String connectURI, String driver, 
    56                         String username, String password) { 
     81        private void setupDataSource(String connectURI, String driver, 
     82                        String username, String password) throws ResourceNotAvailable { 
    5783                BasicDataSource ds = new BasicDataSource(); 
    5884                ds.setDriverClassName(driver); 
     
    6086                ds.setPassword(password); 
    6187                ds.setUrl(connectURI); 
    62                 return ds; 
     88                dataSource = ds; 
     89 
    6390        } 
    64  
     91         
    6592        private void shutdownDataSource(DataSource ds) throws SQLException { 
    6693                BasicDataSource bds = (BasicDataSource) ds; 
    6794                bds.close(); 
    6895        }        
     96         
     97        private void lookupDataSource() throws ResourceNotAvailable { 
     98                InitialContext cxt; 
     99                 
     100                try { 
     101                        cxt = new InitialContext(); 
     102                } catch (NamingException e) { 
     103                        throw new ResourceNotAvailable( 
     104                                        new NdgMessage("context.not.available",  
     105                                                        new Object[]{}, null), e); 
     106 
     107                } 
     108                 
     109                if ( cxt == null ) { 
     110                        throw new ResourceNotAvailable( 
     111                                        new NdgMessage("context.not.available",  
     112                                                        new Object[]{}, null)); 
     113                } 
     114 
     115                try { 
     116                        dataSource = (DataSource) cxt.lookup( jndiDataSource ); 
     117                } catch (NamingException e) { 
     118                        // TODO Auto-generated catch block 
     119                        e.printStackTrace(); 
     120                } 
     121 
     122                if ( dataSource == null ) { 
     123                        throw new ResourceNotAvailable( 
     124                                        new NdgMessage("datasource.not.available",  
     125                                                        new Object[]{jndiDataSource}, null)); 
     126                } 
     127        } 
     128         
     129        /** 
     130         * Opens and close a connection to test the availability of the resource. 
     131         *  
     132         * @exception ResourceNotAvailable if is not possible to open a <code>Connection</code> 
     133         **/ 
     134        private void testConnection() throws ResourceNotAvailable { 
     135                try { 
     136                        Connection conn = getConnection(); 
     137                        conn.close(); 
     138                } catch (SQLException e) { 
     139                        throw new ResourceNotAvailable(e); 
     140                } 
     141        } 
    69142} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/common/messages.properties

    r6504 r6510  
    66sql.command = Executing \n {0} 
    77invocation.error = The command {0} generated an unexpected exception 
     8context.not.available = No context is available 
     9datasource.not.available = The datasource {0} is not available 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/medin/DiscoveryBasic.java

    r6461 r6510  
    2020 * Contains the main objects which support the marin service 
    2121 *  
    22  * @author Maurizio Nagni <maurizio.nagni@stcf.ac.uk>  
     22 * @author Maurizio Nagni <maurizio.nagni@stcf.ac.uk> 
    2323 **/ 
    2424public class DiscoveryBasic { 
    25          
     25 
    2626        /** The database connection */ 
    2727        private NdgBasicDataSource dataSource; 
     
    3636        private final static DiscoveryBasic instance = new DiscoveryBasic(); 
    3737 
    38         private static Logger logger = Logger.getLogger(DiscoveryDBException.class 
    39                         .getName()); 
     38        private static Logger logger = Logger.getLogger(DiscoveryDBException.class.getName()); 
    4039 
    4140        // Hides the constructor 
     
    4544        /** 
    4645         * Returns a connection to the underlying datasource 
     46         *  
    4747         * @return a <code>Connection</code> instance 
    48          * @exception NdgException if <code>Connection</code> is not available 
     48         * @exception NdgException 
     49         *                if <code>Connection</code> is not available 
    4950         * */ 
    5051        public final Connection getConnection() throws ResourceNotAvailable { 
     
    5758        /** 
    5859         * Returns the instance of the underlying singleton. 
     60         *  
    5961         * @return the singleton instance 
    6062         * */ 
     
    6264                return instance; 
    6365        } 
    64          
     66 
    6567        /** Return a MARIN specific {@link MessageFormatter} instance */ 
    6668        public final MessageFormatter getFormatter() { 
     
    7274 
    7375        /** 
    74          * Returns the configuration properties  
     76         * Returns the configuration properties 
     77         *  
    7578         * @return the configuration properties 
    76          * @throws ResourceNotAvailable if the properties are not available 
     79         * @throws ResourceNotAvailable 
     80         *             if the properties are not available 
    7781         */ 
    7882        public final Properties getConfigurationProperties() throws ResourceNotAvailable { 
    7983                if (configurationProperties == null) { 
    80                         InputStream in = this.getClass().getClassLoader() 
    81                                         .getResourceAsStream( 
    82                                                         DiscoveryDictionary.DEFAULT_PROPERTIES_FILENAME); 
     84                        InputStream in = this.getClass().getClassLoader().getResourceAsStream( 
     85                                        DiscoveryDictionary.DEFAULT_PROPERTIES_FILENAME); 
    8386                        try { 
    8487                                loadConfigurationStream(in); 
    8588                        } catch (IOException e) { 
    86                                 throw new ResourceNotAvailable(getFormatter() 
    87                                                 .getFormattedText(new NdgMessage("config.not.loaded.error",  
    88                                                                 new Object[]{DiscoveryDictionary.DEFAULT_PROPERTIES_FILENAME}))); 
     89                                throw new ResourceNotAvailable(getFormatter().getFormattedText( 
     90                                                new NdgMessage("config.not.loaded.error", 
     91                                                                new Object[] { DiscoveryDictionary.DEFAULT_PROPERTIES_FILENAME }))); 
    8992                        } 
    9093                } 
     
    9598                ResourceBundle bundle = null; 
    9699                try { 
    97                         bundle = ResourceBundle 
    98                                         .getBundle(DiscoveryDictionary.RESOURCE_BUNDLE); 
     100                        bundle = ResourceBundle.getBundle(DiscoveryDictionary.RESOURCE_BUNDLE); 
    99101                } catch (MissingResourceException ex) { 
    100102                        logger.error("No resource bundle could be found!"); 
    101103                } 
    102104                return bundle; 
    103         }        
    104          
    105         private void loadConfigurationStream(InputStream in) throws IOException, 
    106                 ResourceNotAvailable { 
     105        } 
     106 
     107        private void loadConfigurationStream(InputStream in) throws IOException, ResourceNotAvailable { 
    107108                if (in == null) 
    108                         throw new ResourceNotAvailable(getFormatter() 
    109                                         .getFormattedText(new NdgMessage("config.not.found.error",  
    110                                                         new Object[]{DiscoveryDictionary.DEFAULT_PROPERTIES_FILENAME})));                                        
     109                        throw new ResourceNotAvailable(getFormatter().getFormattedText( 
     110                                        new NdgMessage("config.not.found.error", 
     111                                                        new Object[] { DiscoveryDictionary.DEFAULT_PROPERTIES_FILENAME }))); 
    111112                configurationProperties = new Properties(); 
    112113                try { 
     
    116117                } 
    117118        } 
    118          
     119 
    119120        private NdgBasicDataSource getDataSource() throws ResourceNotAvailable { 
    120121                if (dataSource == null) { 
    121                         dataSource = new NdgBasicDataSource( 
    122                                         getConfigurationProperties().getProperty(DiscoveryDictionary.JDBC_URI),  
    123                                         getConfigurationProperties().getProperty(DiscoveryDictionary.JDBC_DRIVER), 
    124                                         getConfigurationProperties().getProperty(DiscoveryDictionary.JDBC_USERNAME), 
    125                                         getConfigurationProperties().getProperty(DiscoveryDictionary.JDBC_PSW)); 
     122                        try { 
     123                                if (getConfigurationProperties().containsKey(DiscoveryDictionary.DISCOVERY_DB_JNDI)) { 
     124                                        dataSource = new NdgBasicDataSource(getConfigurationProperties().getProperty( 
     125                                                        DiscoveryDictionary.DISCOVERY_DB_JNDI)); 
     126                                } else { 
     127                                        tryManualConfiguration(); 
     128                                } 
     129                        } catch (ResourceNotAvailable e) { 
     130                                tryManualConfiguration(); 
     131                        }  
    126132                } 
    127133                return dataSource; 
    128134        } 
     135         
     136        private void tryManualConfiguration() throws ResourceNotAvailable{ 
     137                if (getConfigurationProperties().containsKey(DiscoveryDictionary.JDBC_URI)) { 
     138                        dataSource = new NdgBasicDataSource(getConfigurationProperties().getProperty( 
     139                                        DiscoveryDictionary.JDBC_URI), getConfigurationProperties().getProperty( 
     140                                        DiscoveryDictionary.JDBC_DRIVER), getConfigurationProperties().getProperty( 
     141                                        DiscoveryDictionary.JDBC_USERNAME), getConfigurationProperties().getProperty( 
     142                                        DiscoveryDictionary.JDBC_PSW)); 
     143                } 
     144        } 
    129145} 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/medin/DiscoveryDictionary.java

    r6505 r6510  
    2222        public final static String JDBC_USERNAME = "jdbc.username";      
    2323        public final static String JDBC_PSW = "jdbc.password"; 
     24         
     25        /** JNDI connection */ 
     26        public final static String DISCOVERY_DB_JNDI = "jndi.discoveryDB"; 
    2427         
    2528        public static enum TermTarget { 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/java/ndg/services/discovery/model/SearchAgent.java

    r6505 r6510  
    144144                List<String> ret = new ArrayList<String>(); 
    145145                try { 
    146                         while (rs != null && (rs.getRow() != 0) && !rs.isLast()) { 
    147                                 rs.next(); 
     146                        while (rs != null && rs.next()) { 
    148147                                ret.add(rs.getString(1)); 
    149148                        } 
     
    192191                        while (true) { 
    193192                                try { 
    194                                         if ((rs.getRow() == 0) || !rs.next()) 
     193                                        if (!rs.next()) 
    195194                                                break; 
    196195                                } catch (SQLException e) { 
  • TI01-discovery-API/trunk/MEDINDiscoveryService/src/main/resources/service.properties

    r6456 r6510  
     1# if this property is active, the connection to the DB will be  
     2# done using a JNDI resource, in an already configured server 
     3jndi.discoveryDB = java:/comp/env/jdbc/discoveryDB 
     4 
     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 
    110jdbc.uri = jdbc:postgresql://neptune.badc.rl.ac.uk:5432/discovery_dev 
    211jdbc.username = badc 
Note: See TracChangeset for help on using the changeset viewer.