Changeset 36


Ignore:
Timestamp:
01/04/06 16:31:30 (14 years ago)
Author:
vahur
Message:

search for content from remote toolboxes via xmlrpc

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/ToolboxSearchTool.py

    r19 r36  
    11from OFS.SimpleItem import SimpleItem 
     2from OFS.SimpleItem import Item 
     3from OFS.PropertyManager import PropertyManager 
    24from Products.CMFCore.utils import UniqueObject 
    35from Globals import InitializeClass 
     6from AccessControl import ClassSecurityInfo 
    47from Products.CMFCore.utils import getToolByName 
     8import xmlrpclib 
     9from Acquisition import aq_base 
    510 
    6 class ToolboxSearchTool(SimpleItem, UniqueObject): 
    7     """ toolbox search """ 
     11class ToolboxSearchTool(PropertyManager, SimpleItem, UniqueObject): 
     12    """ toolbox search. Performs standard plone search and xml-rpc search to query distant toolboxes """ 
    813 
    914    id = 'toolbox_search' 
    1015    meta_type = 'ToolboxSearch' 
     16    security = ClassSecurityInfo() 
    1117    plone_tool = 1 
     18 
     19    def manage_afterAdd(self, item, container): 
     20        self._setProperty('remote_toolboxes', [], 'lines') 
    1221 
    1322    def toolbox_search(self, REQUEST, **kw): 
    1423    """ toolbox search method. performs local and remote searches """ 
     24        class myremotebrain: 
     25            """ my brain """ 
     26            __allow_access_to_unprotected_subobjects__=1 
     27            def __init__(self, ob, data): 
     28                self.__ob = ob 
     29                self.data = data 
     30                 
     31            def __get__(self, key): 
     32                try: 
     33                    return self.data[key] 
     34                except: 
     35                    print "ERROR: ", key 
     36 
     37            def __getattr__(self, key, default=''): 
     38                if self.data.has_key(key): 
     39                    return self.data[key] 
     40                return getattr(self.__ob, key) 
     41 
     42        results = [] 
     43        local = self.local_search(REQUEST, **kw) 
     44        remote = self.remote_search(REQUEST, **kw) 
     45        for x in local: 
     46            results.append(x) 
     47        for y in remote: 
     48            rbrain = myremotebrain(aq_base(self).__of__(self),y) 
     49            results.append(rbrain) 
     50    return results 
     51 
     52    security.declarePrivate('local_search') 
     53    def local_search(self, REQUEST, **kw): 
     54        """ do a local search """ 
    1555    portal_catalog = getToolByName( self, 'portal_catalog' ) 
    1656    results = portal_catalog.searchResults(REQUEST, **kw) 
    17     # TODO: do remote search 
    18     return results 
     57        return results 
     58 
     59    security.declarePrivate('remote_search') 
     60    def remote_search(self, REQUEST, **kw): 
     61        """ do remote search. 
     62            connects to distant toolbox via xml-rpc and invokes incoming_query method. 
     63        """ 
     64        # get remote toolbox address from somewhere 
     65        tb_locations = self.get_remote_toolboxes() 
     66        result = [] 
     67        if tb_locations is None: 
     68            return result 
     69        for tb in tb_locations: 
     70            ping = self.ping(tb) 
     71            if not ping: 
     72                print "Toolbox @ %s is alive!" % tb 
     73                # connect now! 
     74                r = xmlrpclib.Server(tb+'/'+self.getId(), allow_none=1) 
     75                query_str = REQUEST.get('QUERY_STRING') 
     76                query = {} 
     77                q_tmp = query_str.split('&') 
     78                params = [] 
     79                for pair in q_tmp: 
     80                    key_tmp, value = pair.split('=') 
     81                    key = key_tmp.split('%')[0] 
     82                    if key not in params: 
     83                        params.append(key) 
     84                for p in params: 
     85                    query[p] = REQUEST.get(p) 
     86                #XXX: this is evil. need to find out if unix timestamps are ok here. 
     87                query['created'] = str(query['created']) 
     88                result += r.incoming_search(query) 
     89                #XXX: when passing **kw 
     90                #XXX: TypeError: __call__() got an unexpected keyword argument 'use_types_blacklist' 
     91            else: 
     92                print "Toolbox @ %s is dead!" % tb 
     93        return result 
     94 
     95    security.declarePublic('incoming_search') 
     96    def incoming_search(self, query): 
     97        """ search request coming from remote toolbox uses this method """ 
     98        from DateTime import DateTime 
     99        #XXX: this is evil. need to find out if unix timestamps are ok here. 
     100        # mybrains object doesn't want to travel over xml-rpc... 
     101        query['created'] = eval(query['created']) 
     102        query_results = self.local_search(query) 
     103        results = [] 
     104        for x in query_results: 
     105            # XXX: should use schema values here? 
     106            results.append({'Title':x.Title,  
     107                    'Description':x.Description, 
     108                    'pretty_title_or_id':x.pretty_title_or_id(), 
     109                    'Creator':x.Creator, 
     110                    'ModificationDate':x.ModificationDate, 
     111                    'getURL':x.getURL(), 
     112                    'portal_type':x.portal_type, 
     113                    'review_state':x.review_state, 
     114                    'data_record_normalized_score_':x.data_record_normalized_score_, 
     115                    }) 
     116        return results 
     117 
     118    security.declarePrivate('get_remote_toolboxes') 
     119    def get_remote_toolboxes(self): 
     120        """ get remote toolbox locations. ie. ('http://localhost:9090/SecondToolBox',) """ 
     121        result = self.getProperty('remote_toolboxes') 
     122        return result 
     123 
     124    def ping(self, address): 
     125        """ ping remote toolbox, see if it's alive """ 
     126        address = address +'/'+ self.getId() 
     127        r = xmlrpclib.Server(address) 
     128        remote = r.pong('ping') 
     129        if remote != 'pong': 
     130            return 1 
     131        return 0 
     132 
     133    def pong(self, ping): 
     134        """ respond to ping """ 
     135        if ping != 'ping': 
     136            return 1 
     137        return "pong" 
    19138 
    20139InitializeClass(ToolboxSearchTool) 
  • trunk/skins/toolbox/toolbox_search_results.pt

    r19 r36  
    2424                 use_view_action site_properties/typesUseViewActionInListings;"> 
    2525 
    26     <h1 i18n:translate="heading_search_results">Search results</h1> 
     26    <h1 i18n:translate="heading_search_results">Local Search results</h1> 
    2727 
    2828    <div tal:condition="not: results"> 
     
    3535    <a href="" 
    3636       i18n:translate="search_results_advanced_link" 
    37        tal:attributes="href string:$portal_url/search_form">Advanced Search</a> 
     37       tal:attributes="href string:$portal_url/toolbox_search_form">Advanced Search</a> 
    3838    </span> 
    3939    for more precise search options. 
Note: See TracChangeset for help on using the changeset viewer.