Azure Web App Temp file cleaning responsibility

Question

In one of my Azure Web App Web API application, I am creating temp files using this code in a Get method

    string path = Path.GetTempFileName();
    // do some writing on this file. then read 
    var fileStream = File.OpenRead(path);
    // then returning this stream as a HttpResponseMessage response

My question is, in a managed environment like this (not in VM), do I need to clear those temporary files by myself? Shouldn't Azure itself supposed to clear those temp files?

Answer 1

Those files only get cleaned when your site is restarted.

If your site is running in Free or Shared mode, it only gets 300MB for temp files, so you could run out if you don't clean up.

If your site is in Basic or Standard mode, then there is significantly more space (around 200GB!). So you could probably get away with not cleaning up without running into the limit. Eventually, your site will get restarted (e.g. during platform upgrade), so things will get cleaned up.

See this page for some additional detail on this topic.

Answer 2

Maybey if you extend FileStream you can override dispose and remove it when disposed is called? That is how i'm resolving it for now. If i'm wrong let me know.

 /// <summary>
/// Create a temporary file and removes its when the stream is closed.
/// </summary>
internal class TemporaryFileStream : FileStream
{
    public TemporaryFileStream() : base(Path.GetTempFileName(), FileMode.Open)
    {
    }

    protected override void Dispose(bool disposing)
    {
        base.Dispose(disposing);

        // After the stream is closed, remove the file.
        File.Delete(Name);
    }
}

Answer 3

Following sample demonstrate how to save temp file in azure, both Path and Bolb.

Doc is here:https://code.msdn.microsoft.com/How-to-store-temp-files-in-d33bbb10
Code click here:https://github.com/Azure-Samples/storage-blob-dotnet-store-temp-files/archive/master.zip

Under part is the core logic of bolb code:

private long TotalLimitSizeOfTempFiles = 100 * 1024 * 1024;

private async Task SaveTempFile(string fileName, long contentLenght, Stream inputStream)
{
    try
    {
        await container.CreateIfNotExistsAsync();

        CloudBlockBlob tempFileBlob = container.GetBlockBlobReference(fileName);

        tempFileBlob.DeleteIfExists();

        await CleanStorageIfReachLimit(contentLenght);

        tempFileBlob.UploadFromStream(inputStream);
    }
    catch (Exception ex)
    {
        if (ex.InnerException != null)
        {
            throw ex.InnerException;
        }
        else
        {
            throw ex;
        }
    }
}

private async Task CleanStorageIfReachLimit(long newFileLength)
{
    List<CloudBlob> blobs = container.ListBlobs()
        .OfType<CloudBlob>()
        .OrderBy(m => m.Properties.LastModified)
        .ToList();

    long totalSize = blobs.Sum(m => m.Properties.Length);

    long realLimetSize = TotalLimitSizeOfTempFiles - newFileLength;

    foreach (CloudBlob item in blobs)
    {
        if (totalSize <= realLimetSize)
        {
            break;
        }

        await item.DeleteIfExistsAsync();
        totalSize -= item.Properties.Length;
    }
}