staffilesystem.cpp

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

        STAFString fromname(fromNameT);
            
        if (MoveFile(fromname.toCurrentCodePage()->buffer(),
                     STAFString(toName).toCurrentCodePage()->buffer()) == FALSE)
        {
            if (osRC) *osRC = GetLastError();
            retCode = kSTAFBaseOSError;
        }
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSOSGetExclusiveFileLock(STAFStringConst_t path,
                                      STAFFSOSFileLock_t *lock,
                                      unsigned int *osRC)
{
    if (path == 0) return kSTAFInvalidParm;
    if (lock == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        STAFString filename(path);
        unsigned int flags = FILE_SHARE_READ | FILE_SHARE_WRITE;

        if (isWinNT()) flags |= FILE_SHARE_DELETE;

        HANDLE theFile = CreateFile(filename.toCurrentCodePage()->buffer(),
                                    GENERIC_READ | GENERIC_WRITE, flags,
                                    0, OPEN_EXISTING, 0, 0);

        if (theFile == INVALID_HANDLE_VALUE)
        {
            if (osRC) *osRC = GetLastError();
            return kSTAFBaseOSError;
        }

        BOOL rc = TRUE;

        while (((rc = LockFile(theFile, 0xFFFFFFFE, 0, 1, 0)) ==
                FALSE) &&
               (GetLastError() == ERROR_LOCK_VIOLATION))
        {
            STAFThreadManager::sleepCurrentThread(200);
        }

        if (rc == FALSE)
        {
            if (osRC) *osRC = GetLastError();
            CloseHandle(theFile);
            return kSTAFBaseOSError;
        }

        *lock = new STAFFSOSFileLockImpl(theFile);
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSOSReleaseExclusiveFileLock(STAFFSOSFileLock_t *lock,
                                          unsigned int *osRC)
{
    if (lock == 0) return kSTAFInvalidObject;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        if (UnlockFile((**lock).handle, 0xFFFFFFFE, 0, 1, 0) == FALSE)
        {
            // Note: We fall through here so that we can close the file and
            //       free the lock

            if (osRC) *osRC = GetLastError();
            retCode = kSTAFBaseOSError;
        }

        CloseHandle((**lock).handle);

        delete *lock;

        *lock = 0;
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSFreeEntry(STAFFSEntry_t *entry)
{
    if (entry == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        delete *entry;
        *entry = 0;
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


/*****************************************************************************/
/*                             Directory APIs                                */
/*****************************************************************************/

STAFRC_t STAFFSCreateDirectory(STAFStringConst_t path,
                               STAFFSDirectoryCreateMode_t flags,
                               unsigned int *osRC)
{
    if (path == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        STAFString directory(path);

        if (GetFileAttributes(
            directory.toCurrentCodePage()->buffer()) != 0xFFFFFFFF)
        {
            return kSTAFAlreadyExists;
        }

        if (flags == kSTAFFSCreateDirOnly)
        {
            BOOL rc = CreateDirectory(directory.toCurrentCodePage()->buffer(),
                                      0);
            if (rc == FALSE)
            {
                if (osRC) *osRC = GetLastError();
                return kSTAFBaseOSError;
            }
        }
        else  // Create entire path
        {
            STAFFSPath fsPath(path);
            STAFFSPath currPath;

            currPath.setRoot(fsPath.root());

            for (unsigned int i = 0; i < fsPath.numDirs(); ++i)
            {
                currPath.addDir(fsPath.dir(i));
                
                CreateDirectory(
                    currPath.asString().toCurrentCodePage()->buffer(), 0);
            }
            
            if (CreateDirectory(fsPath.asString().toCurrentCodePage()->buffer(),
                                0) == FALSE)
            {
                if (osRC) *osRC = GetLastError();
                return kSTAFBaseOSError;
            }
        }
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSGetCurrentDirectory(STAFString_t *path, unsigned int *osRC)
{
    if (path == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSSetCurrentDirectory(STAFStringConst_t path, unsigned int *osRC)
{
    if (path == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSEnumOpen(STAFFSEnumHandle_t *enumHandle, STAFFSEntry_t entry,
                        STAFStringConst_t namePattern,
                        STAFStringConst_t extPattern,
                        STAFFSCaseSensitive_t caseSensitive,
                        STAFFSEntryType_t entryTypes,
                        STAFFSSortBy_t sortBy, unsigned int *osRC)
{
    if (enumHandle == 0) return kSTAFInvalidParm;
    if (entry == 0) return kSTAFInvalidObject;

    STAFRC_t retCode = kSTAFOk;

    if (caseSensitive == kSTAFFSCaseDefault)
        STAFFSInfo(&caseSensitive, kSTAFFSCaseSensitivity);

    try
    {
        STAFStringConst_t rootName = 0;
        STAFRC_t rc = STAFFSEntryGetPathString(entry, &rootName, osRC);

        if (rc) return rc;

        STAFFSEnumHandleImpl enumData;

        STAFString theRootName(rootName);
        STAFString theRootNameFilter(rootName + sBackSlash + sStar);
        STAFString theNamePattern(namePattern);
        STAFString theExtPattern(extPattern);

        if (theNamePattern.length() == 0) theNamePattern = kUTF8_STAR;
        if (theExtPattern.length() == 0) theExtPattern = kUTF8_STAR;

        WIN32_FIND_DATA data = { 0 };
        HANDLE dirHandle = FindFirstFile(
                           theRootNameFilter.toCurrentCodePage()->buffer(),
                           &data);

        if (dirHandle == INVALID_HANDLE_VALUE)
        {
            // Ignore this error as it is a duplicate of an error that is
            // caught in another place.  Also, this error can occur if the
            // directory has already been deleted in an earlier enumeration.

            *enumHandle = new STAFFSEnumHandleImpl(enumData);
            return kSTAFOk;
        }
        else if (dirHandle == FALSE)
        {
            // Return the error

            int errNum = GetLastError();
            *enumHandle = new STAFFSEnumHandleImpl(enumData);

            // XXX: 0 is not correct, find the correct error for no files found

            if ((errNum != 0) && osRC)
                *osRC = errNum;

            return kSTAFBaseOSError;
        }
        else
        {
            // Loop through all the entries in the directory and see if they
            // match the name and extension patterns

            do
            {
                // Ignore . and .. unless the user specifically requests them
                //
                // Note: Win32 doesn't return a ".." entry when scanning a
                //       "first-level" directory such as c:\dev.  This appears
                //       to be related to the fact that c:\ can't be used in
                //       FindFirstFile() (see STAFFSGetEntry).

                if (!(entryTypes & kSTAFFSSpecialDirectory) &&
                    ((STAFString(data.cFileName) == sPeriod) ||
                     (STAFString(data.cFileName) == (sPeriod + sPeriod))))
                {
                    continue;
                }

                STAFString pathName(theRootName);

                pathName += STAFString(sBackSlash);
                pathName += data.cFileName;

                STAFFSPath path(pathName);
            
                if ((STAFFileSystem::matchesWildcards(path.name(),
                                                      theNamePattern,
                                                      caseSensitive)) &&
                    (STAFFileSystem::matchesWildcards(path.extension(),
                                                      theExtPattern,
                                                      caseSensitive)))
                {
                    // Now, make sure that we can get the associated entry and
                    // that it matches the requested types

                    STAFFSEntry_t goodEntry = 0;
                    STAFFSEntryType_t entryType = kSTAFFSOther;

                    rc = STAFFSGetEntry(path.asString().getImpl(),
                                        &goodEntry, 0);

                    if (rc != 0) continue;

                    rc = STAFFSEntryGetType(goodEntry, &entryType, 0);
          
                    if ((rc == 0) && (entryType & entryTypes))
                        enumData.entries.push_back(goodEntry);
                    else
                        STAFFSFreeEntry(&goodEntry);
                }
            } while ((FindNextFile(dirHandle, &data) != 0) &&
                     (dirHandle != INVALID_HANDLE_VALUE));

            FindClose(dirHandle);
        }

        switch (sortBy)
        {
            case kSTAFFSSortByName:
            {
                std::sort(enumData.entries.begin(), enumData.entries.end(),
                          STAFSortEnumByName(caseSensitive));
                break;
            }

            case kSTAFFSSortBySize:
            {
                std::sort(enumData.entries.begin(), enumData.entries.end(),
                          sortEnumBySize);
                break;
            }

            case kSTAFFSSortByModTime:
            {
                std::sort(enumData.entries.begin(), enumData.entries.end(),
                          sortEnumByModTime);
                break;
            }

            default: break;
        }

        *enumHandle = new STAFFSEnumHandleImpl(enumData);
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSEnumNext(STAFFSEnumHandle_t enumHandle, STAFFSEntry_t *entry,
                        unsigned int *osRC)
{
    if (enumHandle == 0) return kSTAFInvalidObject;
    if (entry == 0) return kSTAFInvalidParm;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        if (enumHandle->entries.size() == 0)
        {
            *entry = 0;
        }
        else
        {
            *entry = enumHandle->entries.front();
            enumHandle->entries.pop_front();
        }
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}


STAFRC_t STAFFSEnumClose(STAFFSEnumHandle_t *enumHandle, unsigned int *osRC)
{
    if (enumHandle == 0) return kSTAFInvalidObject;

    STAFRC_t retCode = kSTAFOk;

    try
    {
        for (STAFFSEntryList::iterator iter = (*enumHandle)->entries.begin();
             iter != (*enumHandle)->entries.end(); ++iter)
        {
            STAFFSEntry_t entry = *iter;

            STAFFSFreeEntry(&entry);
        }

        delete *enumHandle;

        *enumHandle = 0;
    }
    catch (...)
    { retCode = kSTAFUnknownError; }

    return retCode;
}