pystaf.py

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

#!/usr/bin/python
#############################################################################
# Software Testing Automation Framework (STAF)                              #
# (C) Copyright IBM Corp. 2001, 2005                                        #
#                                                                           #
# This software is licensed under the Common Public License (CPL) V1.0.     #
#############################################################################

import PYSTAF

# Utility functions

def STAFWrapData(message):
    return ":%d:%s" % (len(message), message)

# Allows you to access this function using either name
wrapData = STAFWrapData

# Privacy utility methods

def STAFAddPrivacyDelimiters(data):
    return "%s" % (PYSTAF.STAFAddPrivacyDelimiters(data))

def STAFEscapePrivacyDelimiters(data):
    return "%s" % (PYSTAF.STAFEscapePrivacyDelimiters(data))

def STAFMaskPrivateData(data):
    return "%s" % (PYSTAF.STAFMaskPrivateData(data))

def STAFRemovePrivacyDelimiters(data, numLevels = 0):
    return "%s" % (PYSTAF.STAFRemovePrivacyDelimiters(data, numLevels))
    
# Allows you to access these functions using either name
addPrivacyDelimiters = STAFAddPrivacyDelimiters
escapePrivacyDelimiters = STAFEscapePrivacyDelimiters
maskPrivateData = STAFMaskPrivateData
removePrivacyDelimiters = STAFRemovePrivacyDelimiters

# STAFException class

class STAFException:

    def __init__(self, rc = 0, result = ""):
        self.rc = rc
        self.result = result

# STAFResult class

class STAFResult:

    Ok                          = 0
    InvalidAPI                  = 1
    UnknownService              = 2
    InvalidHandle               = 3
    HandleAlreadyExists         = 4
    HandleDoesNotExist          = 5
    UnknownError                = 6
    InvalidRequestString        = 7
    InvalidServiceResult        = 8
    REXXError                   = 9
    BaseOSError                 = 10
    ProcessAlreadyComplete      = 11
    ProcessNotComplete          = 12
    VariableDoesNotExist        = 13
    UnResolvableString          = 14
    InvalidResolveString        = 15
    NoPathToMachine             = 16
    FileOpenError               = 17
    FileReadError               = 18
    FileWriteError              = 19
    FileDeleteError             = 20
    STAFNotRunning              = 21
    CommunicationError          = 22
    TrusteeDoesNotExist         = 23
    InvalidTrustLevel           = 24
    AccessDenied                = 25
    STAFRegistrationError       = 26
    ServiceConfigurationError   = 27
    QueueFull                   = 28
    NoQueueElement              = 29
    NotifieeDoesNotExist        = 30
    InvalidAPILevel             = 31
    ServiceNotUnregisterable    = 32
    ServiceNotAvailable         = 33
    SemaphoreDoesNotExist       = 34
    NotSemaphoreOwner           = 35
    SemaphoreHasPendingRequests = 36
    Timeout                     = 37
    JavaError                   = 38
    ConverterError              = 39
    InvalidObject               = 41
    InvalidParm                 = 42
    RequestNumberNotFound       = 43
    InvalidAsynchOption         = 44
    RequestNotComplete          = 45
    ProcessAuthenticationDenied = 46
    InvalidValue                = 47
    DoesNotExist                = 48
    AlreadyExists               = 49
    DirectoryNotEmpty           = 50
    DirectoryCopyError          = 51
    DiagnosticsNotEnabled       = 52
    HandleAuthenticationDenied  = 53
    HandleAlreadyAuthenticated  = 54
    InvalidSTAFVersion          = 55
    RequestCancelled            = 56

    def __init__(self, rc = 0, result = ""):
        self.rc = rc
        self.result = result

# STAFHandle class

class STAFHandle:

    # STAFHandle types

    Standard = 0
    Static   = 1

    # Modes for submit call

    Synchronous   = 0
    FireAndForget = 1
    Queue         = 2
    Retain        = 3
    QueueRetain   = 4

    # Note: I would have liked to have used STAFHandle.Standard in place of "0"
    #       in the methods below, but the class hasn't been defined yet.

    def __init__(self, handleNameOrNumber, handleType = 0):

        self.handleType = handleType

        if (handleType == STAFHandle.Standard):
            rc, self.handle = PYSTAF.STAFRegister(handleNameOrNumber)
            if (rc != 0):
                raise STAFException(rc)
        else:
            self.handle = handleNameOrNumber

    def submit(self, location, service, request, mode = Synchronous):
        rc, result = PYSTAF.STAFSubmit(self.handle, mode, location, service,
                                       request)
        return STAFResult(rc, result)

    def unregister(self):
        if (self.handleType == 0):
            rc = PYSTAF.STAFUnregister(self.handle)
            if (rc != 0):
                raise STAFException(rc)
            self.handle = 0

        return 0


# Marshalling constants and imports

import types

UNMARSHALLING_DEFAULTS  = 0
IGNORE_INDIRECT_OBJECTS = 1

MARSHALLED_DATA_MARKER = '@SDT/'
NONE_MARKER            = '@SDT/$0:0:'
SCALAR_MARKER          = '@SDT/$'
SCALAR_STRING_MARKER   = '@SDT/$S'
LIST_MARKER            = '@SDT/['
MAP_MARKER             = '@SDT/{'
MC_INSTANCE_MARKER     = '@SDT/%'
CONTEXT_MARKER         = '@SDT/*'

# Formatting constants and imports

import os

NONE_STRING            = '<None>'
DISPLAY_NAME_KEY       = 'display-name'
MAP_CLASS_MAP_KEY      = 'map-class-map'
MAP_CLASS_NAME_KEY     = 'staf-map-class-name'
ENTRY_SEPARATOR        = ''
INDENT_DELTA           = 2
# 80 spaces
SPACES = ('                                         ' + 
          '                                         ')

# STAFMapClassDefinitionClass

class STAFMapClassDefinition:
    # Constructors
    def __init__(self, name = None, mapClassDef = None):
        if (mapClassDef is None) and (name is None):
            self.mapClassDef = { 'name': '', 'keys': [] }
        elif (name is not None):
            self.mapClassDef = { 'name': name, 'keys': [] }
        else:
            self.mapClassDef = mapClassDef

    def createInstance(self):
        return { 'staf-map-class-name' : self.mapClassDef['name'] }

    def addKey(self, keyName, displayName = None):
        theKey = { 'key': keyName }
        if displayName is not None:
            theKey['display-name'] = displayName
        self.mapClassDef['keys'].append(theKey)

    def setKeyProperty(self, keyName, property, value):
        for key in self.mapClassDef['keys']:
            if key['key'] == keyName:
                key[property] = value

    def keys(self):
        return self.mapClassDef['keys']

    def name(self):
        return self.mapClassDef['name']

    def getMapClassDefinitionObject(self):
        return self.mapClassDef

    def __str__(self):
        return formatObject(self.mapClassDef)

    def __repr__(self):
        return formatObject(self.mapClassDef)

# STAFMarshallingContext class

class STAFMarshallingContext:

    def isMarshalledData(self, someData):
        return someData.startswith('@SDT/')

    def __init__(self, obj = None, mapClassMap = None):
        if mapClassMap is None:
            self.mapClassMap = {}
        else:
            self.mapClassMap = mapClassMap
        self.rootObject = obj

    def setMapClassDefinition(self,  mapClassDef):
        self.mapClassMap[mapClassDef.name()] = mapClassDef.getMapClassDefinitionObject()

    def getMapClassDefinition(self, mapClassName):
        return STAFMapClassDefinition(
            mapClassDef = self.mapClassMap.get(mapClassName, None))

    def hasMapClassDefinition(self, mapClassName):
        return self.mapClassMap.has_key(mapClassName)

    def getMapClassMap(self):
        return self.mapClassMap

    def mapClassDefinitionIterator(self):
        return self.mapClassMap.keys()

    def setRootObject(self, rootObject):
        self.rootObject = rootObject

    def getRootObject(self):
        return self.rootObject

    def getPrimaryObject(self):
        if  len(self.mapClassMap.keys()) == 0:
            return self.rootObject
        else:
            return self

    def marshall(self):
        return marshall(self, self)

    def __str__(self):
        return formatObject(self.rootObject, self)

    # XXX: Change to show the key map class in addition?
    def __repr__(self):
        return formatObject(self.rootObject, self)

# Function that tests if a string is marshalled data

def isMarshalledData(someData):
    return someData.startswith('@SDT/')

# General marshalling function

def marshall(object, context = None):
    if object is None:
        return NONE_MARKER

    if type(object) == types.ListType:

        # Build a list of strings and join them for performance reasons

        listDataList = []

        for item in object:
            listDataList.append(marshall(item, context))

        listData = ''.join(listDataList)

        return "%s%s:%s:%s" % (LIST_MARKER, len(object), len(listData), listData)

    if type(object) == types.DictType:

        # If a staf-map-class-name key exists in the map, make sure that
        # it's map class definition is provided in the marshalling context.
        # If it's not, then treat the map as a plain map object.

        isMapClass = 0
        mapClassName = ''

        if ((context is not None) and
            (isinstance(context, STAFMarshallingContext)) and
            (object.has_key('staf-map-class-name'))):

            mapClassName = object['staf-map-class-name']

            if context.hasMapClassDefinition(mapClassName):
                isMapClass = 1

        if isMapClass:

            mapClass = context.getMapClassDefinition(mapClassName)

            # Build a list of strings and join them for performance reasons

            mapDataList = []
            mapDataList.append(":%s:%s" % (len(mapClassName), mapClassName))

            for key in mapClass.keys():

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

                mapDataList.append(marshall(thisObj, context))

            mapData = ''.join(mapDataList)

            return "%s:%s:%s" % (MC_INSTANCE_MARKER, len(mapData), mapData)

        else:

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

            for key in object.keys():
                mapDataList.append(
                    ":%s:%s%s" % (len(str(key)), str(key),
                                  marshall(object[key], context)))
            
            mapData = ''.join(mapDataList)

            return "%s:%s:%s" % (MAP_MARKER, len(mapData), mapData)

    if isinstance(object, STAFMarshallingContext):

        if len(object.mapClassMap.keys()) == 0:
            return marshall(object.getRootObject(), context)
        else:
            contextMap = { 'map-class-map': object.mapClassMap }

            # Note: We can't simply put the root object as a map key like
            #       "root-object" and then marshall the whole map, as in