Produits Entr'ouvert » w.c.s.

# w.c.s. - web application for online forms

# Copyright (C) 2005-2010  Entr'ouvert

#

# This program 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.

#

# This program 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 this program; if not, see <http://www.gnu.org/licenses/>.

try:

    import lasso

except ImportError:

    lasso = None

import soap

import sys

class IdWsfInteraction(Exception):

    '''Signal the need for an ID-WSF 2.0 Interaction redirect.

       URL of the redirect and ID to refer and the new request are returned

       through this exception.

    '''

    url = None

    id = None

    def __init__(self, profile):

        self.url = profile.msgUrl

        self.id = profile.getSoapEnvelopeResponse().getMessageId()

    def __str__(self):

        return '<IdWsfInteraction url:%s id:%s>' % (self.ulr, self.id)

# FIXME: move me somewhere else found useful

class CanLog(object):

    '''Encapsulate what is needed for an object which wants to log some

    messages.

       Use setLogger(logger) to give specific logging capabilities to your

       object. If not set warn(), error() and info() will print on stderr.

    '''

    __logger = None

    def __formatMessage(self, args):

        context=''

        if hasattr(self, 'loggerContext'):

            context=self.loggerContext()

        return context+' '.join(map(str, args))

    def setLogger(self, logger):

        __logger = logger

    def getLogger(self):

        return __logger

    def __do(self, what, prefix, args):

        message = self.__formatMessage(args)

        if self.__logger and hasattr(self.__logger, what):

            getprop(self.__logger, what)(message)

        else:

            print >>sys.stderr, prefix, message

    def warn(self, *args):

        self.__do('warn', 'Warning:', args)

    def error(self, *args):

        self.__do('error', 'Error:', args)

    def info(self, *args):

        self.__do('info', 'Info:', args)

class IdWsfClient(CanLog,object):

    '''Do basic work flow to make ID-WSF 2.0 requests.

       reply_id allows to re-iterate a request which necessitates an

       interaction, you must fill it with the value of id attribute

       of an IdWsfInteraction exception.

       interactions is a boolean telling the remote services whether we support

       interactions.

       '''

    interactions = False

    epr = None

    url = None

    reply_id = None

    client_cert = None

    def __init__(self, epr = None, server = None, url = None, logger = None):

        self.epr = epr

        self.server = server

        self.url = url

        self.logger = logger

    def _initRequest(self, profile, *args, **kwargs):

        profile.setEpr(self.epr)

    def _doRequest(self, profile, *args, **kwargs):

        try:

            envelope = profile.getSoapEnvelopeRequest()

            if self.reply_id:

                envelope.setRelatesTo(self.reply_id)

            if self.interactions and not self.reply_id:

                envelope.setSb2UserInteractionHint( \

                        lasso.IDWSF2_SB2_USER_INTERACTION_HINT_INTERACT_IF_NEEDED)

            else:

                envelope.setSb2UserInteractionHint( \

                        lasso.IDWSF2_SB2_USER_INTERACTION_HINT_DO_NOT_INTERACT)

            profile.buildRequestMsg(*args, **kwargs)

            url = profile.msgUrl

            if not url:

                url = self.url

            response = soap.soapCall(url, profile.msgBody,

                    key = kwargs.get('key'), cert = kwargs.get('cert'))

            profile.processResponseMsg(response)

        # Handle Interaction Service

        except lasso.WsfprofileRedirectRequestError:

            if self.interactions:

                e=IdWsfInteraction(profile)

                self.reply_id=e.id

                raise e

            else:

                raise

class IdWsfService(CanLog,object):

    interactions = False

    epr = None

    url = None

    reply_id = None

    client_cert = None

    tracer = None

    def __init__(self, server = None, logger = None):

        self.server = server

        self.logger = None

    def soapFail(self, profile, message = None, code = 'server'):

        '''Return a SOAP fault to requester'''

        if not message:

            message = "Unknown server error"

        if code == 'server':

            profile.initSoapFaultResponse(lasso.SOAP_FAULT_CODE_SERVER, message)

        else:

            profile.initSoapFaultResponse(lasso.SOAP_FAULT_CODE_CLIENT, message)

    def processRequest(self, message, check_security = False, security_mechanism = None):

        profile = self.profile

        try:

            profile.processRequestMsg(message)

            if check_security:

                profile.checkSecurityMechanism(security_mechanism)

            request_type = profile.getRequestType()

            handler=self._dispatch_table.get(request_type, self.soapFail)

            handler(profile, True)

            profile.validateRequest()

            handler(profile, False)

        except Exception, e:

            self.error('SOAP Request failed:',e)

            self.soapFail(profile)

        else:

            if not profile.response:

                self.soapFail(profile)

        profile.buildResponseMsg()

        return profile.msgBody

    def _doNothing(self, disco, before):

        pass

class DiscoveryClient2(IdWsfClient):

    def __init__(self, *args, **kwargs):

        super(DiscoveryClient2, self).__init__(*args, **kwargs)

        self.profile = lasso.IdWsf2Discovery(self.server)

    def loggerContext(self):

        context={}

        if self.profile and self.profile.msgUrl:

            context['url'] = self.profile.msgUrl

        context['interactions'] = self.interactions

        if self.reply_id:

            context['reply_id'] = self.reply_id

        return 'DiscoClient context: %s -- ' % context

    def lookupService(self, *service_types):

        try:

            disco = self.profile

            self._initRequest(disco)

            disco.initQuery()

            disco.addRequestedService(service_types=service_types)

            self._doRequest(disco)

            return disco.getEndpointReferences()

        except IdWsfInteraction, interaction:

            raise

        except Exception, e:

            self.error(e)

            return []

    def queryServices(self, svcmdids=()):

        try:

            disco = self.profile

            self._initRequest(disco)

            disco.initMetadataQuery()

            disco.svcmdids = tuple(svcmdids)

            self._doRequest(disco)

            return disco.metadatas

        except IdWsfInteraction, interaction:

            raise

        except Exception, e:

            self.error(e)

            return []

    def registerService(self, service_types=(), provider_id=None, abstract = None, address = None, security_mechanisms = ()):

        try:

            disco = self.profile

            self._initRequest(disco)

            disco.initMetadataRegister()

            disco.addSimpleServiceMetadata(service_types=service_types,

                    provider_id = provider_id, abstract=abstract,

                    address = address,

                    security_mechanisms = tuple(security_mechanisms))

            self._doRequest(disco)

            return disco.metadatas[0].svcMDID

        except IdWsfInteraction, interaction:

            raise

        except Exception, e:

            self.error(e)

            return None

    def deleteService(self, svcMDIDs):

        try:

            disco = self.profile

            self._initRequest(disco)

            disco.initMetadataDelete()

            disco.svcmdids = tuple(svcMDIDs)

            self._doRequest(disco)

            return True

        except IdWsfInteraction, interaction:

            raise

        except lasso.Idwsf2DiscoveryNotFoundError:

            self.error('Cannot delete service mdid %s: %s said not found ' % (svcMDIDs, self.profile.msgUrl))

            return True

        except Exception, e:

            raise

    def associate(self, svcMDIDs):

        try:

            disco = self.profile

            self._initRequest(disco)

            disco.initMetadataAssociationAdd()

            disco.svcmdids = tuple(svcMDIDs)

            self._doRequest(disco)

            return True

        except IdWsfInteraction, interaction:

            raise

        except Exception, e:

            self.error('Cannot associate with services', svcMDIDs, ':', e)

            return False

    def dissociate(self, svcMDIDs):

        try:

            disco = self.profile

            self._initRequest(disco)

            disco.initMetadataAssociationDelete()

            disco.svcmdids = tuple(svcMDIDs)

            self._doRequest(disco)

            return True

        except IdWsfInteraction, interaction:

            raise

        except Exception, e:

            self.error('Could not dissociate for', svcMDIDs, ':', e)

            return False

    def queryAssociations(self, svcMDIDs):

        try:

            disco = self.profile

            self._initRequest(disco)

            disco.initMetadataAssociationQuery()

            disco.svcmdids = tuple(svcMDIDs)

            self._doRequest(disco)

            return disco.svcmdids

        except IdWsfInteraction, interaction:

            raise

        except Exception, e:

            self.error('Could not query associations for', svcMDIDs, ':', e)

            return []

class DiscoveryService2(IdWsfService):

    def __init__(self, *args, **kwargs):

        super(DiscoveryService2, self).__init__(*args, **kwargs)

        self._dispatch_table = {

            lasso.IDWSF2_DISCOVERY_REQUEST_TYPE_MD_REGISTER: self.handleMdRegister,

            lasso.IDWSF2_DISCOVERY_REQUEST_TYPE_MD_QUERY: self.handleMdQuery,

            lasso.IDWSF2_DISCOVERY_REQUEST_TYPE_MD_DELETE: self.handleMdDelete,

            lasso.IDWSF2_DISCOVERY_REQUEST_TYPE_MD_ASSOCIATION_ADD: self.handleMdAssociationAdd,

            lasso.IDWSF2_DISCOVERY_REQUEST_TYPE_MD_ASSOCIATION_DELETE: self.handleMdAssociationDelete,

            lasso.IDWSF2_DISCOVERY_REQUEST_TYPE_MD_ASSOCIATION_QUERY: self.handleMdAssociationQuery,

            lasso.IDWSF2_DISCOVERY_REQUEST_TYPE_QUERY: self.handleQuery,

            }

        self.profile = lasso.IdWsf2Discovery(self.server)

    handleMdRegister = IdWsfService._doNothing

    handleMdQuery = IdWsfService._doNothing

    handleMdDelete = IdWsfService._doNothing

    handleMdAssociationAdd = IdWsfService._doNothing

    handleMdAssociationDelete = IdWsfService._doNothing

    handleMdAssociationQuery = IdWsfService._doNothing

    handleQuery = IdWsfService._doNothing

class DSTClient2(IdWsfClient):

    def __init__(self, *args, **kwargs):

        super(DSTClient2, self).__init__(*args, **kwargs)

        self.profile = lasso.IdWsf2DataService(self.server)

    def query(self, queries, flatten=True, namespaces={}):

        try:

            dst=self.profile

            for key, value in namespaces.items():

                dst.addNamespace(key, value)

            self._initRequest(dst)

            dst.initQuery()

            for key, query in queries.items():

                dst.addQueryItem(query, key)

            self._doRequest(dst)

            results = {}

            for key in queries:

                if flatten:

                    v=dst.getQueryItemResultContent(key)

                else:

                    v=dst.getQueryItemResult(key)

                results[key]=v

            return results

        except IdWsfInteraction, interaction:

            raise

        except Exception, e:

            self.error('DST query failed', e)

            return {}

class DSTService2(IdWsfService):

    def __init__(self, *args, **kwargs):

        super(DSTService2, self).__init__(*args, **kwargs)

        self._dispatch_table = {

            lasso.IDWSF2_DATA_SERVICE_REQUEST_TYPE_QUERY: self.handleQuery,

            }

        self.profile = lasso.IdWsf2DataService(self.server)

    handleQuery = IdWsfService._doNothing

# w.c.s. - web application for online forms

# Copyright (C) 2005-2010  Entr'ouvert

#

# This program 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.

#

# This program 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 this program; if not, see <http://www.gnu.org/licenses/>.

import urllib

import httplib

class SOAPException(Exception):

    def __init__(self, msg, err = None, url = None, body = None):

        """SOAP call failure, this is not related to SOAP Fault, which

           are normal SOAP response"""

        self.err = err

        self.url = url

        self.body = body

        super(SOAPException, self).__init__(msg)

    def __str__(self):

        return '<SOAPException url:%s sub-err:%s>' % (self.url, self.err)

def soapCall(url, msg, key = None, cert = None):

    """Use httplib to make a SOAP call, the content of the SOAP message must

       be passed in @msg and the destination in @url.

    """

    if url.startswith('http://'):

        host, query = urllib.splithost(url[5:])

        conn = httplib.HTTPConnection(host)

    else:

        host, query = urllib.splithost(url[6:])

        conn = httplib.HTTPSConnection(host,

                key_file = key or cert, cert_file = cert)

    try:

        conn.request('POST', query, msg, {'Content-Type': 'text/xml'})

        response = conn.getresponse()

    except Exception, err:

        # exception could be raised by request

        raise SOAPException("Connection failed",

                url = url, err = err, body = msg)

    data = response.read()

    conn.close()

    if response.status not in (200, 204): # 204 ok for federation termination

        raise SOAPException("Response status is not OK", url = url,

                body = msg)

    return data

-