Changeset 25862 for gs3-extensions

Show
Ignore:
Timestamp:
28.06.2012 13:02:23 (7 years ago)
Author:
sjm84
Message:

Reformatting this file ahead of some changes

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • gs3-extensions/solr/trunk/src/src/java/org/greenstone/gsdl3/service/GS2SolrSearch.java

    r25766 r25862  
    11/* 
    2 *    GS2SolrSearch.java 
    3 *    Copyright (C) 2006 New Zealand Digital Library, http://www.nzdl.org 
    4 * 
    5 *    This program is free software; you can redistribute it and/or modify 
    6 *   the Free Software Foundation; either version 2 of the License, or 
    7 *    (at your option) any later version. 
    8 * 
    9 *    This program is distributed in the hope that it will be useful, 
    10 *    but WITHOUT ANY WARRANTY; without even the implied warranty of 
    11 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    12 *    GNU General Public License for more details. 
    13 * 
    14 *    You should have received a copy of the GNU General Public License 
    15 *    along with this program; if not, write to the Free Software 
    16 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
    17 */ 
     2 *    GS2SolrSearch.java 
     3 *    Copyright (C) 2006 New Zealand Digital Library, http://www.nzdl.org 
     4 * 
     5 *    This program is free software; you can redistribute it and/or modify 
     6 *   the Free Software Foundation; either version 2 of the License, or 
     7 *    (at your option) any later version. 
     8 * 
     9 *    This program is distributed in the hope that it will be useful, 
     10 *    but WITHOUT ANY WARRANTY; without even the implied warranty of 
     11 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     12 *    GNU General Public License for more details. 
     13 * 
     14 *    You should have received a copy of the GNU General Public License 
     15 *    along with this program; if not, write to the Free Software 
     16 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
     17 */ 
    1818 
    1919package org.greenstone.gsdl3.service; 
    2020 
    2121// Greenstone classes 
    22 import org.greenstone.gsdl3.util.*; 
    23 import org.greenstone.util.GlobalProperties; 
    24  
    25 // XML classes 
    26 import org.w3c.dom.Element;  
    27 import org.w3c.dom.NodeList; 
    28 import org.w3c.dom.Document;  
    29 // java classes 
    30 import java.util.ArrayList; 
     22import java.io.File; 
    3123import java.util.HashMap; 
    32 import java.io.File; 
    3324import java.util.Iterator; 
     25import java.util.Map; 
    3426import java.util.Set; 
    35 import java.util.Map; 
    3627import java.util.Vector; 
    3728 
    38 // Logging 
    3929import org.apache.log4j.Logger; 
    40  
    41 //import org.greenstone.SolrWrapper.GS2SolrQuery; 
    42 //import org.greenstone.SolrWrapper.SolrQueryResult; 
    43 import org.greenstone.LuceneWrapper3.SharedSoleneQueryResult; 
    44  
    4530import org.apache.solr.client.solrj.embedded.EmbeddedSolrServer; 
    4631import org.apache.solr.core.CoreContainer; 
    47  
    48 import java.net.MalformedURLException; 
    49 import java.util.Iterator; 
    50 import java.util.List; 
    51 import java.util.Map; 
    52 import java.util.Map.Entry; 
    53  
    54  
     32import org.greenstone.LuceneWrapper3.SharedSoleneQueryResult; 
     33import org.greenstone.gsdl3.util.GSFile; 
     34import org.greenstone.gsdl3.util.GSXML; 
     35import org.greenstone.gsdl3.util.SolrQueryWrapper; 
     36import org.greenstone.util.GlobalProperties; 
     37import org.w3c.dom.Element; 
    5538 
    5639public class GS2SolrSearch extends SharedSoleneGS2FieldSearch 
    5740{ 
    58     static Logger logger = Logger.getLogger(org.greenstone.gsdl3.service.GS2SolrSearch.class.getName()); 
    59  
    60     static protected CoreContainer all_solr_cores = null; 
    61  
    62     protected HashMap solr_core_cache; 
    63     protected SolrQueryWrapper solr_src=null; 
    64      
    65     public GS2SolrSearch() 
    66     { 
    67     // Used to store the solr cores that match the required 'level'  
    68     // of search (e.g. either document-level=>didx, or  
    69     // section-level=>sidx.  The hashmap is filled out on demand 
    70     // based on 'level' parameter passed in to 'setUpQueryer()' 
    71  
    72     solr_core_cache = new HashMap();  
    73  
    74     if (all_solr_cores == null) { 
    75         // Share one CoreContainer across all sties/collections 
    76         try {  
    77          
    78         String gsdl3_home = GlobalProperties.getGSDL3Home(); 
    79         String solr_ext_name = GlobalProperties.getProperty("gsdlext.solr.dirname","solr"); 
    80          
    81         String solr_home_str = GSFile.extHome(gsdl3_home,solr_ext_name); 
    82         File solr_home = new File(solr_home_str); 
    83         File solr_xml = new File( solr_home,"solr.xml" ); 
    84  
    85         all_solr_cores = new CoreContainer(solr_home_str,solr_xml);              
    86         } 
    87         catch (Exception e) { 
    88         e.printStackTrace(); 
    89         } 
    90     } 
    91  
    92     this.solr_src = new SolrQueryWrapper(); 
    93     } 
    94      
    95  
    96     public void cleanUp() { 
    97     super.cleanUp(); 
    98     this.solr_src.cleanUp(); 
    99     all_solr_cores.shutdown(); 
    100     } 
    101          
    102     /** methods to handle actually doing the query */ 
    103      
    104     /** do any initialisation of the query object */ 
    105     protected boolean setUpQueryer(HashMap params) { 
    106     String indexdir = GSFile.collectionBaseDir(this.site_home, this.cluster_name) + File.separatorChar + "index"+File.separatorChar; 
    107          
    108     String index = "didx"; 
    109     String physical_index_language_name=null; 
    110     String physical_sub_index_name=null; 
    111     int maxdocs = 100; 
    112     int hits_per_page = 20; 
    113     int start_page = 1; 
    114     // set up the query params 
    115     Set entries = params.entrySet(); 
    116     Iterator i = entries.iterator(); 
    117     while (i.hasNext()) { 
    118         Map.Entry m = (Map.Entry)i.next(); 
    119         String name = (String)m.getKey(); 
    120         String value = (String)m.getValue(); 
    121          
    122         if (name.equals(MAXDOCS_PARAM)&& !value.equals("")) { 
    123         maxdocs = Integer.parseInt(value); 
    124         } else if (name.equals(HITS_PER_PAGE_PARAM)) { 
    125         hits_per_page = Integer.parseInt(value); 
    126         } else if (name.equals(START_PAGE_PARAM)) { 
    127         start_page = Integer.parseInt(value); 
    128          
    129         } else if (name.equals(MATCH_PARAM)) { 
    130         if (value.equals(MATCH_PARAM_ALL)) { 
    131             this.solr_src.setDefaultConjunctionOperator("AND"); 
    132         } else{ 
    133             this.solr_src.setDefaultConjunctionOperator("OR"); 
    134         } 
    135         } else if (name.equals(RANK_PARAM)) { 
    136         if (value.equals(RANK_PARAM_RANK_VALUE)) { 
    137             value = null; 
    138         } 
    139         this.solr_src.setSortField(value); 
    140         } else if (name.equals(LEVEL_PARAM)) { 
    141         if (value.toUpperCase().equals("SEC")){ 
    142             index = "sidx"; 
    143         } 
    144         else { 
    145             index = "didx"; 
    146         } 
    147         } else if (name.equals(INDEX_SUBCOLLECTION_PARAM)) { 
    148         physical_sub_index_name=value; 
    149         } else if (name.equals(INDEX_LANGUAGE_PARAM)){ 
    150         physical_index_language_name=value; 
    151         }  // ignore any others 
    152     } 
    153     // set up start and end results if necessary 
    154     int start_results = 1; 
    155     if (start_page != 1) { 
    156         start_results = ((start_page-1) * hits_per_page) + 1; 
    157     } 
    158     int end_results = hits_per_page * start_page; 
    159     this.solr_src.setStartResults(start_results); 
    160     this.solr_src.setEndResults(end_results); 
    161     this.solr_src.setMaxDocs(maxdocs); 
    162  
    163     if (index.equals("sidx") || index.equals("didx")){ 
    164         if (physical_sub_index_name!=null) { 
    165         index+=physical_sub_index_name; 
    166         }    
    167         if (physical_index_language_name!=null){ 
    168         index+=physical_index_language_name; 
    169         } 
    170     } 
    171  
    172  
    173     // now we know the index level, we can dig out the required 
    174     // solr-core, (caching the result in 'solr_core_cache') 
    175  
    176     String site_name = this.router.getSiteName(); 
    177     String coll_name = this.cluster_name; 
    178  
    179     String core_name = site_name + "-" + coll_name + "-" + index; 
    180  
    181     EmbeddedSolrServer solr_core = null; 
    182  
    183     if (!solr_core_cache.containsKey(core_name)) { 
    184         solr_core = new EmbeddedSolrServer(all_solr_cores,core_name);    
    185          
    186         solr_core_cache.put(core_name,solr_core); 
    187     } 
    188     else { 
    189         solr_core = (EmbeddedSolrServer)solr_core_cache.get(core_name); 
    190     } 
    191      
    192     this.solr_src.setSolrCore(solr_core); 
    193     this.solr_src.initialise(); 
    194     return true; 
    195     } 
    196  
    197     /** do the query */ 
    198     protected Object runQuery(String query) { 
    199      
    200     /* 
    201       ModifiableSolrParams solrParams = new ModifiableSolrParams(); 
    202       solrParams.set("collectionName", myCollection); 
    203         solrParams.set("username", "admin"); 
    204         solrParams.set("password", "password"); 
    205         solrParams.set("facet", facet); 
    206         solrParams.set("q", query); 
    207         solrParams.set("start", start); 
    208         solrParams.set("rows", nbDocuments); 
    209         return server.query(solrParams); 
    210         */ 
    211  
    212     /* 
    213     SolrQuery solrQuery = new SolrQuery(); 
    214     solrQuery.setQuery(query); 
    215     //solrQuery.set("collectionName", myCollection); 
    216     solrQuery.set("username", "admin"); 
    217     solrQuery.set("password", "password"); 
    218     solrQuery.set("facet", facet); 
    219     solrQuery.setStart(start); 
    220     solrQuery.setRows(nbDocuments); 
    221     //return server.query(solrQuery); 
    222     */ 
    223      
    224     try { 
    225         SharedSoleneQueryResult sqr=this.solr_src.runQuery(query); 
    226         return sqr; 
    227     } catch (Exception e) { 
    228         logger.error ("Exception happened in run query: ", e); 
    229     } 
    230      
    231     return null; 
    232     } 
    233  
    234     /** get the total number of docs that match */ 
    235     protected long numDocsMatched(Object query_result) { 
    236     return ((SharedSoleneQueryResult)query_result).getTotalDocs(); 
    237      
    238     } 
    239  
    240     /** get the list of doc ids */ 
    241     protected String [] getDocIDs(Object query_result) { 
    242     Vector docs = ((SharedSoleneQueryResult)query_result).getDocs(); 
    243     String [] doc_nums = new String [docs.size()]; 
    244     for (int d = 0; d < docs.size(); d++) { 
    245         String doc_num = ((SharedSoleneQueryResult.DocInfo) docs.elementAt(d)).id_; 
    246         doc_nums[d] = doc_num; 
    247     } 
    248     return doc_nums; 
    249     } 
    250  
    251     /** get the list of doc ranks */ 
    252     protected String [] getDocRanks(Object query_result) { 
    253     Vector docs = ((SharedSoleneQueryResult)query_result).getDocs(); 
    254     String [] doc_ranks = new String [docs.size()]; 
    255     for (int d = 0; d < docs.size(); d++) { 
    256         doc_ranks[d] = Float.toString(((SharedSoleneQueryResult.DocInfo) docs.elementAt(d)).rank_); 
    257     } 
    258     return doc_ranks; 
    259     } 
    260  
    261     /** add in term info if available */ 
    262     protected boolean addTermInfo(Element term_list, HashMap params, 
    263                   Object query_result) { 
    264     String query_level = (String)params.get(LEVEL_PARAM); // the current query level 
    265      
    266     Vector terms = ((SharedSoleneQueryResult)query_result).getTerms(); 
    267     for (int t = 0; t < terms.size(); t++) { 
    268         SharedSoleneQueryResult.TermInfo term_info = (SharedSoleneQueryResult.TermInfo) terms.get(t); 
    269          
    270         Element term_elem = this.doc.createElement(GSXML.TERM_ELEM); 
    271         term_elem.setAttribute(GSXML.NAME_ATT, term_info.term_); 
    272         term_elem.setAttribute(FREQ_ATT, "" + term_info.term_freq_); 
    273         term_elem.setAttribute(NUM_DOCS_MATCH_ATT, "" + term_info.match_docs_); 
    274         term_elem.setAttribute(FIELD_ATT, term_info.field_); 
    275         term_list.appendChild(term_elem); 
    276     } 
    277      
    278     Vector stopwords = ((SharedSoleneQueryResult)query_result).getStopWords(); 
    279     for (int t = 0; t < stopwords.size(); t++) { 
    280         String stopword = (String) stopwords.get(t); 
    281          
    282         Element stopword_elem = this.doc.createElement(GSXML.STOPWORD_ELEM); 
    283         stopword_elem.setAttribute(GSXML.NAME_ATT, stopword); 
    284         term_list.appendChild(stopword_elem); 
    285     } 
    286      
    287     return true; 
    288     } 
    289      
     41    static Logger logger = Logger.getLogger(org.greenstone.gsdl3.service.GS2SolrSearch.class.getName()); 
     42 
     43    static protected CoreContainer all_solr_cores = null; 
     44 
     45    protected HashMap solr_core_cache; 
     46    protected SolrQueryWrapper solr_src = null; 
     47 
     48    public GS2SolrSearch() 
     49    { 
     50        // Used to store the solr cores that match the required 'level'  
     51        // of search (e.g. either document-level=>didx, or  
     52        // section-level=>sidx.  The hashmap is filled out on demand 
     53        // based on 'level' parameter passed in to 'setUpQueryer()' 
     54 
     55        solr_core_cache = new HashMap(); 
     56 
     57        if (all_solr_cores == null) 
     58        { 
     59            // Share one CoreContainer across all sties/collections 
     60            try 
     61            { 
     62 
     63                String gsdl3_home = GlobalProperties.getGSDL3Home(); 
     64                String solr_ext_name = GlobalProperties.getProperty("gsdlext.solr.dirname", "solr"); 
     65 
     66                String solr_home_str = GSFile.extHome(gsdl3_home, solr_ext_name); 
     67                File solr_home = new File(solr_home_str); 
     68                File solr_xml = new File(solr_home, "solr.xml"); 
     69 
     70                all_solr_cores = new CoreContainer(solr_home_str, solr_xml); 
     71            } 
     72            catch (Exception e) 
     73            { 
     74                e.printStackTrace(); 
     75            } 
     76        } 
     77 
     78        this.solr_src = new SolrQueryWrapper(); 
     79    } 
     80 
     81    public void cleanUp() 
     82    { 
     83        super.cleanUp(); 
     84        this.solr_src.cleanUp(); 
     85        all_solr_cores.shutdown(); 
     86    } 
     87 
     88    /** methods to handle actually doing the query */ 
     89 
     90    /** do any initialisation of the query object */ 
     91    protected boolean setUpQueryer(HashMap params) 
     92    { 
     93        String indexdir = GSFile.collectionBaseDir(this.site_home, this.cluster_name) + File.separatorChar + "index" + File.separatorChar; 
     94 
     95        String index = "didx"; 
     96        String physical_index_language_name = null; 
     97        String physical_sub_index_name = null; 
     98        int maxdocs = 100; 
     99        int hits_per_page = 20; 
     100        int start_page = 1; 
     101        // set up the query params 
     102        Set entries = params.entrySet(); 
     103        Iterator i = entries.iterator(); 
     104        while (i.hasNext()) 
     105        { 
     106            Map.Entry m = (Map.Entry) i.next(); 
     107            String name = (String) m.getKey(); 
     108            String value = (String) m.getValue(); 
     109 
     110            if (name.equals(MAXDOCS_PARAM) && !value.equals("")) 
     111            { 
     112                maxdocs = Integer.parseInt(value); 
     113            } 
     114            else if (name.equals(HITS_PER_PAGE_PARAM)) 
     115            { 
     116                hits_per_page = Integer.parseInt(value); 
     117            } 
     118            else if (name.equals(START_PAGE_PARAM)) 
     119            { 
     120                start_page = Integer.parseInt(value); 
     121 
     122            } 
     123            else if (name.equals(MATCH_PARAM)) 
     124            { 
     125                if (value.equals(MATCH_PARAM_ALL)) 
     126                { 
     127                    this.solr_src.setDefaultConjunctionOperator("AND"); 
     128                } 
     129                else 
     130                { 
     131                    this.solr_src.setDefaultConjunctionOperator("OR"); 
     132                } 
     133            } 
     134            else if (name.equals(RANK_PARAM)) 
     135            { 
     136                if (value.equals(RANK_PARAM_RANK_VALUE)) 
     137                { 
     138                    value = null; 
     139                } 
     140                this.solr_src.setSortField(value); 
     141            } 
     142            else if (name.equals(LEVEL_PARAM)) 
     143            { 
     144                if (value.toUpperCase().equals("SEC")) 
     145                { 
     146                    index = "sidx"; 
     147                } 
     148                else 
     149                { 
     150                    index = "didx"; 
     151                } 
     152            } 
     153            else if (name.equals(INDEX_SUBCOLLECTION_PARAM)) 
     154            { 
     155                physical_sub_index_name = value; 
     156            } 
     157            else if (name.equals(INDEX_LANGUAGE_PARAM)) 
     158            { 
     159                physical_index_language_name = value; 
     160            } // ignore any others 
     161        } 
     162        // set up start and end results if necessary 
     163        int start_results = 1; 
     164        if (start_page != 1) 
     165        { 
     166            start_results = ((start_page - 1) * hits_per_page) + 1; 
     167        } 
     168        int end_results = hits_per_page * start_page; 
     169        this.solr_src.setStartResults(start_results); 
     170        this.solr_src.setEndResults(end_results); 
     171        this.solr_src.setMaxDocs(maxdocs); 
     172 
     173        if (index.equals("sidx") || index.equals("didx")) 
     174        { 
     175            if (physical_sub_index_name != null) 
     176            { 
     177                index += physical_sub_index_name; 
     178            } 
     179            if (physical_index_language_name != null) 
     180            { 
     181                index += physical_index_language_name; 
     182            } 
     183        } 
     184 
     185        // now we know the index level, we can dig out the required 
     186        // solr-core, (caching the result in 'solr_core_cache') 
     187 
     188        String site_name = this.router.getSiteName(); 
     189        String coll_name = this.cluster_name; 
     190 
     191        String core_name = site_name + "-" + coll_name + "-" + index; 
     192 
     193        EmbeddedSolrServer solr_core = null; 
     194 
     195        if (!solr_core_cache.containsKey(core_name)) 
     196        { 
     197            solr_core = new EmbeddedSolrServer(all_solr_cores, core_name); 
     198 
     199            solr_core_cache.put(core_name, solr_core); 
     200        } 
     201        else 
     202        { 
     203            solr_core = (EmbeddedSolrServer) solr_core_cache.get(core_name); 
     204        } 
     205 
     206        this.solr_src.setSolrCore(solr_core); 
     207        this.solr_src.initialise(); 
     208        return true; 
     209    } 
     210 
     211    /** do the query */ 
     212    protected Object runQuery(String query) 
     213    { 
     214 
     215        /* 
     216         * ModifiableSolrParams solrParams = new ModifiableSolrParams(); 
     217         * solrParams.set("collectionName", myCollection); 
     218         * solrParams.set("username", "admin"); solrParams.set("password", 
     219         * "password"); solrParams.set("facet", facet); solrParams.set("q", 
     220         * query); solrParams.set("start", start); solrParams.set("rows", 
     221         * nbDocuments); return server.query(solrParams); 
     222         */ 
     223 
     224        /* 
     225         * SolrQuery solrQuery = new SolrQuery(); solrQuery.setQuery(query); 
     226         * //solrQuery.set("collectionName", myCollection); 
     227         * solrQuery.set("username", "admin"); solrQuery.set("password", 
     228         * "password"); solrQuery.set("facet", facet); 
     229         * solrQuery.setStart(start); solrQuery.setRows(nbDocuments); //return 
     230         * server.query(solrQuery); 
     231         */ 
     232 
     233        try 
     234        { 
     235            SharedSoleneQueryResult sqr = this.solr_src.runQuery(query); 
     236            return sqr; 
     237        } 
     238        catch (Exception e) 
     239        { 
     240            logger.error("Exception happened in run query: ", e); 
     241        } 
     242 
     243        return null; 
     244    } 
     245 
     246    /** get the total number of docs that match */ 
     247    protected long numDocsMatched(Object query_result) 
     248    { 
     249        return ((SharedSoleneQueryResult) query_result).getTotalDocs(); 
     250 
     251    } 
     252 
     253    /** get the list of doc ids */ 
     254    protected String[] getDocIDs(Object query_result) 
     255    { 
     256        Vector docs = ((SharedSoleneQueryResult) query_result).getDocs(); 
     257        String[] doc_nums = new String[docs.size()]; 
     258        for (int d = 0; d < docs.size(); d++) 
     259        { 
     260            String doc_num = ((SharedSoleneQueryResult.DocInfo) docs.elementAt(d)).id_; 
     261            doc_nums[d] = doc_num; 
     262        } 
     263        return doc_nums; 
     264    } 
     265 
     266    /** get the list of doc ranks */ 
     267    protected String[] getDocRanks(Object query_result) 
     268    { 
     269        Vector docs = ((SharedSoleneQueryResult) query_result).getDocs(); 
     270        String[] doc_ranks = new String[docs.size()]; 
     271        for (int d = 0; d < docs.size(); d++) 
     272        { 
     273            doc_ranks[d] = Float.toString(((SharedSoleneQueryResult.DocInfo) docs.elementAt(d)).rank_); 
     274        } 
     275        return doc_ranks; 
     276    } 
     277 
     278    /** add in term info if available */ 
     279    protected boolean addTermInfo(Element term_list, HashMap params, Object query_result) 
     280    { 
     281        String query_level = (String) params.get(LEVEL_PARAM); // the current query level 
     282 
     283        Vector terms = ((SharedSoleneQueryResult) query_result).getTerms(); 
     284        for (int t = 0; t < terms.size(); t++) 
     285        { 
     286            SharedSoleneQueryResult.TermInfo term_info = (SharedSoleneQueryResult.TermInfo) terms.get(t); 
     287 
     288            Element term_elem = this.doc.createElement(GSXML.TERM_ELEM); 
     289            term_elem.setAttribute(GSXML.NAME_ATT, term_info.term_); 
     290            term_elem.setAttribute(FREQ_ATT, "" + term_info.term_freq_); 
     291            term_elem.setAttribute(NUM_DOCS_MATCH_ATT, "" + term_info.match_docs_); 
     292            term_elem.setAttribute(FIELD_ATT, term_info.field_); 
     293            term_list.appendChild(term_elem); 
     294        } 
     295 
     296        Vector stopwords = ((SharedSoleneQueryResult) query_result).getStopWords(); 
     297        for (int t = 0; t < stopwords.size(); t++) 
     298        { 
     299            String stopword = (String) stopwords.get(t); 
     300 
     301            Element stopword_elem = this.doc.createElement(GSXML.STOPWORD_ELEM); 
     302            stopword_elem.setAttribute(GSXML.NAME_ATT, stopword); 
     303            term_list.appendChild(stopword_elem); 
     304        } 
     305 
     306        return true; 
     307    } 
    290308 
    291309}