Exemple #1
0
uint32 FChunkWriter::FQueuedChunkWriter::Run()
{
	// Loop until there's no more chunks
	while ( ShouldBeRunning() )
	{
		FChunkFile* ChunkFile = GetNextChunk();
		if( ChunkFile != NULL )
		{
			const FGuid& ChunkGuid = ChunkFile->ChunkHeader.Guid;
			const uint64& ChunkHash = ChunkFile->ChunkHeader.RollingHash;
#if SAVE_OLD_CHUNKDATA_FILENAMES
			const FString OldChunkFilename = FBuildPatchUtils::GetChunkOldFilename( ChunkDirectory, ChunkGuid );
#endif
			const FString NewChunkFilename = FBuildPatchUtils::GetChunkNewFilename( EBuildPatchAppManifestVersion::GetLatestVersion(), ChunkDirectory, ChunkGuid, ChunkHash );

			// To be a bit safer, make a few attempts at writing chunks
			int32 RetryCount = 5;
			bool bChunkSaveSuccess = false;
			while ( RetryCount > 0 )
			{
				// Write out chunks
				bChunkSaveSuccess = WriteChunkData( NewChunkFilename, ChunkFile, ChunkGuid );
#if SAVE_OLD_CHUNKDATA_FILENAMES
				bChunkSaveSuccess = bChunkSaveSuccess && WriteChunkData( OldChunkFilename, ChunkFile, ChunkGuid );
#endif
				// Check success
				if( bChunkSaveSuccess )
				{
					RetryCount = 0;
				}
				else
				{
					// Retry after a second if failed
					--RetryCount;
					FPlatformProcess::Sleep( 1.0f );
				}
			}

			// If we really could not save out chunk data successfully, this build will never work, so panic flush logs and then cause a hard error.
			if( !bChunkSaveSuccess )
			{
				GLog->PanicFlushThreadedLogs();
				check( bChunkSaveSuccess );
			}

			// Delete the data memory
			delete ChunkFile;
		}
		FPlatformProcess::Sleep( 0.0f );
	}
	return 0;
}
Exemple #2
0
int WriteOutDTD(struct DTDesc *TheDTDesc)
{
    struct IFFHandle *IH;
    struct FileDataTypeHeader FileDTH;
    int i;

    if(!TheDTDesc)
    {
        return(FALSE);
    }

    if(strlen(TheDTDesc->Name)==0)
    {
        return(FALSE);
    }

    if(strlen(TheDTDesc->BaseName)==0)
    {
        return(FALSE);
    }

#if 0
    if(TheDTDesc->DTH.dth_MaskLen==0)
    {
        return(FALSE);
    }
#endif

    if(strlen(TheDTDesc->Pattern)==0)
    {
        TheDTDesc->Pattern[0]='#';
        TheDTDesc->Pattern[1]='?';
        TheDTDesc->Pattern[2]='\0';
    }

    IH=NewIFF(TheDTDesc->OutputName, MAKE_ID('D','T','Y','P'));
    if(!IH)
    {
        return(FALSE);
    }

    if(!NewChunk(IH, MAKE_ID('N','A','M','E')))
    {
        CloseIFF(IH);
        remove(TheDTDesc->Name);
        return(FALSE);
    }

    if(WriteChunkData(IH, TheDTDesc->Name, (strlen(TheDTDesc->Name)+1))<=0)
    {
        EndChunk(IH);
        CloseIFF(IH);
        remove(TheDTDesc->Name);
        return(FALSE);
    }

    EndChunk(IH);

    if(strlen(TheDTDesc->Version) > 0)
    {
        if(!NewChunk(IH, MAKE_ID('F','V','E','R')))
        {
            CloseIFF(IH);
            remove(TheDTDesc->Name);
            return(FALSE);
        }

        if(WriteChunkData(IH, TheDTDesc->Version, (strlen(TheDTDesc->Version)+1))<=0)
        {
            EndChunk(IH);
            CloseIFF(IH);
            remove(TheDTDesc->Name);
            return(FALSE);
        }

        EndChunk(IH);
    }

    if(!NewChunk(IH, MAKE_ID('D','T','H','D')))
    {
        CloseIFF(IH);
        remove(TheDTDesc->Name);
        return(FALSE);
    }

    FileDTH.dth_Name     = (((unsigned int) sizeof(struct FileDataTypeHeader)));
    FileDTH.dth_BaseName = (((unsigned int) FileDTH.dth_Name) + strlen(TheDTDesc->DTH.dth_Name) + 1);
    FileDTH.dth_Pattern  = (((unsigned int) FileDTH.dth_BaseName) + strlen(TheDTDesc->DTH.dth_BaseName) + 1);
    FileDTH.dth_Mask     = (((unsigned int) FileDTH.dth_Pattern) + strlen(TheDTDesc->DTH.dth_Pattern) + 1);
    FileDTH.dth_GroupID  = TheDTDesc->DTH.dth_GroupID;
    FileDTH.dth_ID       = TheDTDesc->DTH.dth_ID;
    FileDTH.dth_MaskLen  = TheDTDesc->DTH.dth_MaskLen;
    FileDTH.dth_Pad      = TheDTDesc->DTH.dth_Pad;
    FileDTH.dth_Flags    = TheDTDesc->DTH.dth_Flags;
    FileDTH.dth_Priority = TheDTDesc->DTH.dth_Priority;

    FileDTH.dth_Name     = Swap32IfLE(((uint32_t) FileDTH.dth_Name));
    FileDTH.dth_BaseName = Swap32IfLE(((uint32_t) FileDTH.dth_BaseName));
    FileDTH.dth_Pattern  = Swap32IfLE(((uint32_t) FileDTH.dth_Pattern));
    FileDTH.dth_Mask     = Swap32IfLE(((uint32_t) FileDTH.dth_Mask));
    FileDTH.dth_GroupID  = Swap32IfLE(FileDTH.dth_GroupID);
    FileDTH.dth_ID       = Swap32IfLE(FileDTH.dth_ID);
    FileDTH.dth_MaskLen  = Swap16IfLE(FileDTH.dth_MaskLen);
    FileDTH.dth_Pad      = Swap16IfLE(FileDTH.dth_Pad);
    FileDTH.dth_Flags    = Swap16IfLE(FileDTH.dth_Flags);
    FileDTH.dth_Priority = Swap16IfLE(FileDTH.dth_Priority);

    if(WriteChunkData(IH, (char *) &FileDTH, sizeof(struct FileDataTypeHeader))<=0)
    {
        EndChunk(IH);
        CloseIFF(IH);
        remove(TheDTDesc->Name);
        return(FALSE);
    }

    if(WriteChunkData(IH, TheDTDesc->DTH.dth_Name, (strlen(TheDTDesc->DTH.dth_Name)+1))<=0)
    {
        EndChunk(IH);
        CloseIFF(IH);
        remove(TheDTDesc->Name);
        return(FALSE);
    }

    if(WriteChunkData(IH, TheDTDesc->DTH.dth_BaseName, (strlen(TheDTDesc->DTH.dth_BaseName)+1))<=0)
    {
        EndChunk(IH);
        CloseIFF(IH);
        remove(TheDTDesc->Name);
        return(FALSE);
    }

    if(WriteChunkData(IH, TheDTDesc->DTH.dth_Pattern, (strlen(TheDTDesc->DTH.dth_Pattern)+1))<=0)
    {
        EndChunk(IH);
        CloseIFF(IH);
        remove(TheDTDesc->Name);
        return(FALSE);
    }

    for(i=0; i<TheDTDesc->DTH.dth_MaskLen; i++)
    {
        TheDTDesc->DTH.dth_Mask[i]=Swap16IfLE(TheDTDesc->DTH.dth_Mask[i]);
    }

    if (TheDTDesc->DTH.dth_MaskLen)
    {
        if(WriteChunkData(IH, (char *) TheDTDesc->DTH.dth_Mask, TheDTDesc->DTH.dth_MaskLen*sizeof(uint16_t))<=0)
        {
            EndChunk(IH);
            CloseIFF(IH);
            remove(TheDTDesc->Name);
            return(FALSE);
        }
    }

    EndChunk(IH);

    CloseIFF(IH);

    return(TRUE);
}