pystaf.py

Software Testing Automation Framework (STAF)的开发代码

            #       the unmarshalling routines, we need to be able to
            #       unmarshall the root object in the context of the
            #       map-class-map.

            mcData = (marshall(contextMap, context) +
                      marshall(object.getRootObject(), object))

            return "%s:%s:%s" % (CONTEXT_MARKER, len(mcData), mcData)

    # if object has method 'marshall':

    return "%s:%s:%s" % (SCALAR_STRING_MARKER, len(str(object)), str(object))


# General unmarshalling function

def unmarshall(data, context = None, flags = UNMARSHALLING_DEFAULTS):
    if context is None:
        context = STAFMarshallingContext()

    if data.startswith(NONE_MARKER):
        return STAFMarshallingContext()

    if data.startswith(SCALAR_MARKER):
        colonIndex = data.find(':')
        colonIndex = data.find(':', colonIndex + 1)

        theString = data[colonIndex + 1:]

        if (theString.startswith(MARSHALLED_DATA_MARKER) and
            ((flags & IGNORE_INDIRECT_OBJECTS) != IGNORE_INDIRECT_OBJECTS)):
            return unmarshall(theString, context, flags)
        else:
            return STAFMarshallingContext(data[colonIndex + 1:])

    if data.startswith(LIST_MARKER):
        colonIndex = data.find(':')
        numItems = int(data[len(LIST_MARKER):colonIndex])
        dataIndex = data.find(':', colonIndex + 1) + 1
        list = []

        for i in range(numItems):
            colonIndex1 = data.find(':', dataIndex)
            colonIndex2 = data.find(':', colonIndex1 + 1)
            itemLength = int(data[colonIndex1 + 1:colonIndex2])

            list.append(
                unmarshall(data[dataIndex:colonIndex2 + itemLength + 1],
                           context, flags).getPrimaryObject())

            dataIndex = colonIndex2 + itemLength + 1

        return STAFMarshallingContext(list)

    if data.startswith(MAP_MARKER):
        colonIndex = data.find(':')
        dataIndex = data.find(':', colonIndex + 1) + 1
        map = {}

        while dataIndex < len(data):
            # Get key first

            keyColonIndex1 = data.find(':', dataIndex)
            keyColonIndex2 = data.find(':', keyColonIndex1 + 1)
            keyLength = int(data[keyColonIndex1 + 1:keyColonIndex2])
            key = data[keyColonIndex2 + 1:keyColonIndex2 + 1 + keyLength]

            dataIndex = keyColonIndex2 + 1 + keyLength

            # Now, get the object

            colonIndex1 = data.find(':', dataIndex)
            colonIndex2 = data.find(':', colonIndex1 + 1)
            itemLength = int(data[colonIndex1 + 1:colonIndex2])

            map[key] = unmarshall(
                data[dataIndex:colonIndex2 + itemLength + 1],
                context, flags).getPrimaryObject()

            dataIndex = colonIndex2 + itemLength + 1

        return STAFMarshallingContext(map)

    if data.startswith(MC_INSTANCE_MARKER):
        colonIndex = data.find(':')
        colonIndex2 = data.find(':', colonIndex + 1)

        colonIndex = data.find(':', colonIndex2 + 1)
        colonIndex2 = data.find(':', colonIndex + 1)

        mapClassNameLength = int(data[colonIndex + 1:colonIndex2])
        mapClassName = data[colonIndex2 + 1 :
                            colonIndex2 + 1 + mapClassNameLength]
        dataIndex = colonIndex2 + 1 + mapClassNameLength
        map = { 'staf-map-class-name': mapClassName }

        mapClass = context.getMapClassDefinition(mapClassName)
        keys = mapClass.keys()
        keyIndex = 0

        while dataIndex < len(data):
            colonIndex = data.find(':', dataIndex)
            colonIndex2 = data.find(':', colonIndex + 1)

            itemLength = int(data[colonIndex + 1:colonIndex2])

            map[keys[keyIndex]['key']] = unmarshall(
                data[dataIndex:colonIndex2 + itemLength + 1],
                context, flags).getPrimaryObject()

            dataIndex = colonIndex2 + itemLength + 1
            keyIndex = keyIndex + 1

        return STAFMarshallingContext(map)

    if data.startswith(CONTEXT_MARKER):
        colonIndex = data.find(':')
        contextIndex = data.find(':', colonIndex + 1) + 1
        contextLength = int(data[colonIndex + 1:contextIndex - 1])

        colonIndex = data.find(':', contextIndex)
        mapIndex = contextIndex
        mapDataIndex = data.find(':', colonIndex + 1) + 1
        mapLength = int(data[colonIndex + 1:mapDataIndex - 1])
        contextMap = unmarshall(data[mapIndex:mapDataIndex + mapLength],
                                context, flags).getPrimaryObject()
        mapClassMap = contextMap['map-class-map']
        newContext = STAFMarshallingContext(None, mapClassMap)

        colonIndex = data.find(':', mapDataIndex + mapLength)

        rootObjIndex = mapDataIndex + mapLength
        rootObjDataIndex = data.find(':', colonIndex + 1) + 1
        rootObjLength = int(data[colonIndex + 1:rootObjDataIndex - 1])

        newContext.setRootObject(
            unmarshall(data[rootObjIndex:rootObjDataIndex + rootObjLength],
                       newContext, flags).getPrimaryObject())

        return newContext

    if data.startswith(MARSHALLED_DATA_MARKER):
        # Here, we don't know what the type is
        return STAFMarshallingContext(data)

    return STAFMarshallingContext(data)


# Formatting function
#
# Notes:
#   1) The indentLevel option is not meant to be used by a user calling
#   the formatObject procedure, thus we don't document it exernally.
#   It's meant to be used internally by the formatObject method when
#   recursively calling itself.
#   2) The flags option is not currently used (it's for future use)

def formatObject(obj, context = None, indentLevel = 0, flags = 0):

    # Build a list of strings to output and join them for performance reasons
    output = []

    if type(obj) == types.ListType:
        list = obj
        output.append('[')
        indentLevel = indentLevel + 1

        if len(list) > 0:
            output.append(os.linesep)

        # Format each object in the list

        i = 0

        for item in list:

            indent = indentLevel * INDENT_DELTA
            output.append(SPACES[: indent])

            if (type(item) == types.ListType or
                type(item) == types.DictType or
                isinstance(item, STAFMarshallingContext)):
                output.append(formatObject(item, context, indentLevel, flags))
            elif item is None:
                output.append(NONE_STRING)
            else:
                output.append(str(item))

            if i < (len(list) - 1):
                output.append(ENTRY_SEPARATOR)

            output.append(os.linesep)

        indentLevel = indentLevel - 1

        if len(list) > 0:
            indent = indentLevel * INDENT_DELTA
            output.append(SPACES[: indent])

        output.append(']')

    elif type(obj) == types.DictType:
        dict = obj
        output.append('{')
        indentLevel = indentLevel + 1

        if len(dict) > 0:
            output.append(os.linesep)
        
        # Check if the map object has a map class key and if the context
        # is valid and contains a map class definition for this map class.
        # If not, treat as a plain map class.

        if (dict.has_key(MAP_CLASS_NAME_KEY) and
            (context is not None) and
            isinstance(context, STAFMarshallingContext) and
            context.hasMapClassDefinition(dict[MAP_CLASS_NAME_KEY])):

            mapClass = context.getMapClassDefinition(dict[MAP_CLASS_NAME_KEY])

            # Determine maximum key length

            maxKeyLength = 0

            for theKey in mapClass.keys():
                theKeyString = theKey['key']

                if theKey.has_key(DISPLAY_NAME_KEY):
                    theKeyString = theKey[DISPLAY_NAME_KEY]
                if len(theKeyString) > maxKeyLength:
                    maxKeyLength = len(theKeyString)

            # Now print each object in the map

            i = 0

            for theKey in mapClass.keys():
                theKeyString = theKey['key']

                if theKey.has_key(DISPLAY_NAME_KEY):
                    theKeyString = theKey[DISPLAY_NAME_KEY]

                indent = indentLevel * INDENT_DELTA
                output.append('%s%s' % (SPACES[: indent], theKeyString))

                indent = maxKeyLength - len(theKeyString)
                output.append('%s: ' % (SPACES[: indent]))

                if dict.has_key(theKey['key']):
                    thisObj = dict[theKey['key']]
                else:
                    thisObj = None

                if (type(thisObj) == types.ListType or
                    type(thisObj) == types.DictType or
                    isinstance(thisObj, STAFMarshallingContext)):
                    output.append(formatObject(thisObj, context, indentLevel, flags))
                elif thisObj is None:
                    output.append(NONE_STRING)
                else:
                    output.append(str(thisObj))

                if i < (len(dict) - 1):
                    output.append(ENTRY_SEPARATOR)
                
                output.append(os.linesep)
                i = i + 1
        
        else:
            # Determine maximum key length

            maxKeyLength = 0

            for theKeyString in dict.keys():
                if len(theKeyString) > maxKeyLength:
                    maxKeyLength = len(theKeyString)

            # Now print each object in the map

            i = 0

            for theKeyString in dict.keys():
                indent = indentLevel * INDENT_DELTA
                output.append('%s%s' % (SPACES[: indent], theKeyString))

                indent = maxKeyLength - len(theKeyString)
                output.append('%s: ' % (SPACES[: indent]))

                thisObj = dict[theKeyString]

                if (type(thisObj) == types.ListType or
                    type(thisObj) == types.DictType or
                    isinstance(thisObj, STAFMarshallingContext)):
                    output.append(formatObject(thisObj, context, indentLevel, flags))
                elif thisObj is None:
                    output.append(NONE_STRING)
                else:
                    output.append(str(thisObj))

                if i < (len(dict) - 1):
                    output.append(ENTRY_SEPARATOR)
                
                output.append(os.linesep)
                i = i + 1
        
        indentLevel = indentLevel - 1

        if len(dict) > 0:
            indent = indentLevel * INDENT_DELTA
            output.append(SPACES[: indent])

        output.append('}')

    elif isinstance(obj, STAFMarshallingContext):
        inputContext = obj
        return formatObject(inputContext.getRootObject(), inputContext,
                            indentLevel, flags)
    elif obj is None:
        return NONE_STRING
    else:
        return str(obj)

    return ''.join(output)


# Used if called as script

if (__name__ == "__main__"):

    import sys

    if len(sys.argv) < 4:
        print "Usage: %s location service request" % sys.argv[0]
        sys.exit(1)

    location = sys.argv[1]
    service = sys.argv[2]
    request = sys.argv[3]

    for requestPart in sys.argv[4:]:
        request = request + " " + requestPart

    try:
        handle = STAFHandle("STAF/Client/Python")
    except STAFException, e:
        print "Error registering with STAF, RC: %d" % e.rc
        sys.exit(e.rc)

    result = handle.submit(location, service, request)

    resultMC = unmarshall(result.result)

    if (result.rc != 0):
        print "Error submitting request, RC: %d" % result.rc

        if (len(result.result) != 0):
            print "Additional info: %s" % resultMC

    else:
        print "Response"
        print "--------"
        print resultMC

    rc = handle.unregister()

    sys.exit(rc)