def __call__(self, account, ob, **kw):
     ob = super(IMessageAdapter, self).__call__(account, ob, **kw)
     idTypeList = kw['idTypeList']
     idList, typeList = splitIDTypeList(idTypeList)
     ids = idFromList(idList)
     types = idFromList(typeList)
     cache.setdefault(ids, {}).setdefault(types, 1)
     import IMessageHandler
     if ob['msgType'] == MESSAGE_TYPE.MESSAGE_GROUP:
         modifiedob = IMessageHandler.handleMessageGroup(ob)
     else:
         modifiedob = IMessageHandler.handle(ob)
     LOG_TRACE('IMessageAdapter. modifiedob %s' % str(modifiedob))
     return modifiedob
    def __separateBuilder(self, ifacename, parentIfacename, ifacedata,
                          idTypeList, result):
        idList, typeList = splitIDTypeList(idTypeList)
        ids = idFromList(idList)
        types = idFromList(typeList)
        piface = getIface(parentIfacename)
        parentdata = {}
        for attr in piface.attr:
            attrdata = ifacedata.get(attr, None)
            if attrdata is not None:
                parentdata[attr] = attrdata

        result.setdefault(ids, {}).setdefault(types, {}).setdefault(
            ifacename, {}).setdefault(parentIfacename, {}).update(parentdata)
        for parentIfacename in getIface(parentIfacename).parent:
            self.__separateBuilder(ifacename, parentIfacename, ifacedata,
                                   idTypeList, result)

        return
        def cacheHandler(request, reqFromCache):
            newrequest = []
            for data, idTypeList in request:
                requestifaces = {}
                idList, typeList = splitIDTypeList(idTypeList)
                ids = idFromList(idList)
                types = idFromList(typeList)
                for ifacename in data:
                    ifacedata = getFromCache(idTypeList, ifacename)
                    if ifacedata is None:
                        requestifaces[ifacename] = data[ifacename]
                    else:
                        reqFromCache.append([{
                            ifacename: data[ifacename]
                        }, idTypeList])

                if requestifaces:
                    newrequest.append([requestifaces, idTypeList])

            return newrequest
        def saveIfaceData(transformedResponse, ifacesdata):
            for ifacedata in ifacesdata:
                ifaces, idTypeList = ifacedata
                idList, typeList = splitIDTypeList(idTypeList)
                ids = idFromList(idList)
                types = idFromList(typeList)
                for parentIfacename in ifaces:
                    names = parentIfacename.split(':')
                    try:
                        parent, ifacename = (
                            parentIfacename,
                            parentIfacename) if len(names) == 1 else names
                    except ValueError:
                        LOG_ERROR('names: {0}'.format(names))
                        parent, ifacename = names[0], names[-1]

                    transformedResponse.setdefault(ids, {}).setdefault(
                        types, {}).setdefault(parent, {}).setdefault(
                            ifacename, {}).update(ifaces[parentIfacename]
                                                  or {})
 def cachedata(ifacesFromCache):
     for obid in transformedResponse:
         for obtype in transformedResponse[obid]:
             idTypeList = joinIDTypeList(listFromId(obid),
                                         listFromId(obtype))
             idList, typeList = splitIDTypeList(idTypeList)
             ids = idFromList(idList)
             types = idFromList(typeList)
             for parentName, ifaces in transformedResponse[obid][
                     obtype].iteritems():
                 for ifacename, attrs in ifaces.iteritems():
                     if not ifacesFromCache.get(ids, {}).get(
                             types, {}).get(ifacename, False):
                         if attrs:
                             setToCache(idTypeList, ifacename,
                                        attrs)
                         else:
                             deleteFromCache(idTypeList, ifacename)
                     else:
                         transformedResponse[obid][obtype][
                             parentName][ifacename] = getFromCache(
                                 idTypeList, ifacename) or {}
Beispiel #6
0
def getObject(idTypeList, account=None):
    initDB()
    idList, typeList = splitIDTypeList(idTypeList)
    if idList and typeList:
        if len(idList) > 1:
            obList = map(
                lambda x: (x[0] if x[0] is None else getObject([x], account)),
                idTypeList)
            return connectors.get(idFromList(typeList),
                                  lambda x, _: x)(obList, account)
        elif idList[0] is None:
            return
        else:
            return connectors.get(typeList[0], lambda x, _: x)(idList[0],
                                                               account)
    return
        def onResponseObBuilt(transformedResponse, reqFromCache, headers,
                              code):
            if self.__requestCount:
                return

            def data():
                for obid in transformedResponse:
                    for obtype in transformedResponse[obid]:
                        idTypeList = joinIDTypeList(listFromId(obid),
                                                    listFromId(obtype))
                        ifacesdata = {}
                        for parent, ifaces in transformedResponse[obid][
                                obtype].iteritems():
                            ifacedata = {}
                            for attrs in ifaces.itervalues():
                                ifacedata.update(attrs)

                            ifacesdata[parent] = ifacedata

                        yield [ifacesdata, idTypeList]

            def cachedata(ifacesFromCache):
                for obid in transformedResponse:
                    for obtype in transformedResponse[obid]:
                        idTypeList = joinIDTypeList(listFromId(obid),
                                                    listFromId(obtype))
                        idList, typeList = splitIDTypeList(idTypeList)
                        ids = idFromList(idList)
                        types = idFromList(typeList)
                        for parentName, ifaces in transformedResponse[obid][
                                obtype].iteritems():
                            for ifacename, attrs in ifaces.iteritems():
                                if not ifacesFromCache.get(ids, {}).get(
                                        types, {}).get(ifacename, False):
                                    if attrs:
                                        setToCache(idTypeList, ifacename,
                                                   attrs)
                                    else:
                                        deleteFromCache(idTypeList, ifacename)
                                else:
                                    transformedResponse[obid][obtype][
                                        parentName][ifacename] = getFromCache(
                                            idTypeList, ifacename) or {}

            ifacesFromCache = {}
            for reqData, idTypeList in reqFromCache:
                idList, typeList = splitIDTypeList(idTypeList)
                ids = idFromList(idList)
                types = idFromList(typeList)
                for ifacename in reqData:
                    reqData[ifacename] = getFromCache(idTypeList,
                                                      ifacename) or {}
                    ifacesFromCache.setdefault(ids, {}).setdefault(
                        types, {})[iface_name(ifacename)] = True

            saveIfaceData(transformedResponse, reqFromCache)
            idata = list(data())
            if code == ErrorCodes.SUCCESS:
                if self.__generateEvent:
                    responseEventGenerate(headers, idata)
                cachedata(ifacesFromCache)
            responseob = [
                headers, idata if code == ErrorCodes.SUCCESS else
                ErrorCodes.ERROR_DESCRIPTION.get(code, 'Unknown error'), code
            ]
            self.__onBuildFinishedCallback(responseob)