root/trunk/LeMillSearchTool.py

# Copyright 2006 by the LeMill Team (see AUTHORS)
#
# This file is part of LeMill.
#
# LeMill is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# LeMill is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with LeMill; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

from OFS.SimpleItem import SimpleItem
from OFS.SimpleItem import Item
from OFS.PropertyManager import PropertyManager
from Products.CMFCore.utils import UniqueObject
from Globals import InitializeClass
from AccessControl import ClassSecurityInfo
from Products.CMFCore.utils import getToolByName
from ZODB.PersistentMapping import PersistentMapping
import xmlrpclib
from socket import gaierror
from xmlrpclib import ProtocolError
from Acquisition import aq_base
from config import MANAGE_PORTAL, ALL_CONTENT_TYPES

class myremotebrain:
    """ my brain """
    __allow_access_to_unprotected_subobjects__=1
    def __init__(self, ob, data):
        self.__ob = ob
        self.data = data
        self.meta_type = self.data['meta_type']
        
    #def __get__(self, key):
    #    try:
    #        return self.data[key]
    #    except:
    #        print "ERROR: ", key

    def __get__(self, value):
        """ bobo """
        try:
            return self.data[name]
        except:
            raise 'aiai'

    def getURL(self):
        """ get url """
        return self.data['getURL']

    def __getitem__(self, name):
        """ get item """
        try:
            return self.data[name]
        except:
            raise 'getitem1'
        raise 'getitem2'

    def getPortalTypeName(self):
        """ portal type """
        return self.data['meta_type']

    def getObject(self):
        """ fake """
        return self

    def getCoverImage(self):
        """ get coverimage """
        class coverImage:
            __allow_access_to_unprotected_subobjects__=1
            def __init__(self, url):
                self.url = url
            def absolute_url(self):
                return self.url+'/coverImage'
        return coverImage(self.data['getURL'])

class LeMillSearchTool(PropertyManager, SimpleItem, UniqueObject):
    """ lemill search. Performs standard plone search and xml-rpc search to query distant lemilles """

    id = 'lemill_search'
    meta_type = 'LeMillSearch'
    security = ClassSecurityInfo()
    plone_tool = 1
    toolicon = 'skins/lemill/tool.gif'
    __allow_access_to_unprotected_subobjects__ = 1

    def __init__(self,id=None):
        #using try-except to solve version incompatibility errors
        try:
            SimpleItem.__init__(self,id)
        except AttributeError:
            pass
        try:
            PropertyManager.__init__(self,id)
        except AttributeError:
            pass
        try:
            UniqueObject.__init__(self,id)
        except AttributeError:
            pass
        self._setProperty('enable_remotesearch', True, 'boolean')
        self.remote_lemilles = {}


    ### Not used 
    def lemill_search(self, REQUEST, **kw):
        """ lemill search method. performs local and remote searches """
        results = []
        if not kw.has_key('portal_type'):
            # limiting search results to meta_types listed below. I wouldn't want junk on my way
            kw['portal_type'] = ALL_CONTENT_TYPES
        if not kw.has_key('getState'):
            kw['getState'] = ('public','draft')
        local = self.local_search(REQUEST, **kw)
        remote = []
        show_deleted=False
        if self.getEnableRemoteSearch():
            remote = self.remote_search(REQUEST, **kw)
        for x in local:
            results.append(x)
        for y in remote:
            rbrain = myremotebrain(aq_base(self).__of__(self),y)
            results.append(rbrain)
        return results

    security.declarePrivate('local_search')
    def local_search(self, REQUEST, **kw):
        """ do a local search """
        portal_catalog = getToolByName( self, 'portal_catalog' )
        results = portal_catalog.searchResults(REQUEST, **kw)
        return results

    security.declarePrivate('remote_search')
    def remote_search(self, REQUEST, **kw):
        """ do remote search.
            connects to distant lemill via xml-rpc and invokes incoming_query method.
        """
        # get remote lemill address from somewhere
        tb_locations = self.get_urls_of_remote_lemilles()
        result = []
        if tb_locations is None:
            return result
        for tb in tb_locations:
            ping = self.ping(tb)
            if not ping:
                #print "LeMill @ %s is alive!" % tb
                # connect now!
                r = xmlrpclib.Server(tb+'/'+self.getId(), allow_none=1)
                query_str = REQUEST.get('QUERY_STRING')
                query = {}
                q_tmp = query_str.split('&')
                params = []
                for pair in q_tmp:
                    key_tmp, value = pair.split('=')
                    key = key_tmp.split('%')[0]
                    if key not in params:
                        params.append(key)
                for p in params:
                    query[p] = REQUEST.get(p)
                #XXX: this is evil. need to find out if unix timestamps are ok here.
                try:
                    query['created'] = str(query['created'])
                except KeyError:
                    pass
                from xmlrpclib import Fault
                try:
                    result += r.incoming_search(query)
                    # Fault: <Fault -1: 'Unexpected Zope exception: exceptions.TypeError - cannot marshal   objects'>
                except Fault:
                    pass
                #XXX: when passing **kw
                #XXX: TypeError: __call__() got an unexpected keyword argument 'use_types_blacklist'
            else:
                print "LeMill @ %s is dead!" % tb
        return result

    security.declarePublic('incoming_search')
    def incoming_search(self, query):
        """ search request coming from remote lemill uses this method """
        from DateTime import DateTime
        #XXX: this is evil. need to find out if unix timestamps are ok here.
        # mybrains object doesn't want to travel over xml-rpc...
        try:
            query['created'] = eval(query['created'])
        except KeyError:
            pass
        query_results = self.local_search(query)
        results = []
        for x in query_results:
            # XXX: should use schema values here?
            rr = {'Title':x.Title, 
                    'meta_type':x.meta_type,
                    'Description':x.Description,
                    'pretty_title_or_id':x.pretty_title_or_id(),
                    'Creator':x.Creator,
                    'ModificationDate':x.ModificationDate,
                    'getURL':x.getURL(),
                    'portal_type':x.portal_type,
                    'getState':x.getState,
                    'data_record_normalized_score_':x.data_record_normalized_score_,
                    'getTags':x.getTags,
                    'Language':x.Language,
                    'absolute_url':x.getURL(),
                    'getURL':x.getURL(),
                    'getHasCoverImage' : x.getHasCoverImage,
                    }
            results.append(rr)
        return results

    def get_urls_of_remote_lemilles(self):
        # get remote lemill locations. ie. ('http://localhost:9090/SecondLeMill',)
        result = []
        for x in self.remote_lemilles.values():
            result.append(x['URL'])
        return result

    def get_remote_lemilles(self):
        return self.remote_lemilles

    def ping(self, address):
        # ping remote lemill, see if it's alive
        address = address +'/'+ self.getId()
        r = xmlrpclib.Server(address)
        try:
            remote = r.pong('ping')
        except (ProtocolError, gaierror):
            #print "incompatible server or failure in name resolution"
            return 1
        except:
            return 1
        if remote != 'pong':
            return 1
        return 0

    def pong(self, ping):
        """ respond to ping """
        if ping != 'ping':
            return 1
        return "pong"

    security.declareProtected(MANAGE_PORTAL, 'setNewLocation')
    def setNewLocation(self, location):
        """ set remote search location and protocol """
        import time 
        timestamp = time.time()
        while self.remote_lemilles.has_key(str(int(timestamp))):
            timestamp = time.time()
        timestamp = str(int(timestamp))
        self.remote_lemilles[timestamp] = {'URL': location, 'protocol': 'xmlrpc'}
        self._p_changed = True
        return 0

    security.declareProtected(MANAGE_PORTAL, 'delete_remote_lemill')
    def delete_remote_lemill(self, id):
        # delete remote lemill address from our list
        del self.remote_lemilles[id]
        self._p_changed = True

    def getEnableRemoteSearch(self):
        return self.enable_remotesearch
    
    security.declareProtected(MANAGE_PORTAL, 'setEnableRemoteSearch')
    def setEnableRemoteSearch(self, enable):
        self.enable_remotesearch = enable


InitializeClass(LeMillSearchTool)