Add/Update Cache Data with Streams

The GetCacheStream method is used to open a stream. It returns the handle of the opened stream as an instance of CacheStream class. In order to add or update data with streams, the streaming mode should be set to write mode. In write mode, multiple write operations can be performed on a stream opened with StreamMode.Write mode by one client.

If the key provided with GetCacheStream API does not exist in the cache, the data written on the stream is added to the cache. If an item already exists in the cache with the provided key, binary data written on the stream is appended with the existing data against the specified key.

To learn about the standard prerequisites required to work with all NCache client side features please refer to the given page on Client Side API Prerequisites.
For API details, refer to: ICache, CacheStream, StreamMode, CacheStreamAttributes, GetCacheStream, Write.

Writing to a Stream

In write mode, multiple write operations can be performed on a stream with StreamMode.Write mode by one client.

.NET/.NET Core
Java

try
{   // Pre-condition: Cache is already connected
    // Generate a unique cache key
    string key = "StreamKey";

    // Set StreamMode object to Write
    StreamMode streamMode = StreamMode.Write;

    // Provide the streamMode in CacheStreamAttributes object
    // CacheStreamAttributes is having properties like 'Group', 'Expiration' e.t.c
    var streamAttributes = new CacheStreamAttributes(streamMode);
    streamAttributes.Group = "VideoDataGroup";

    // Open stream to read video file
    using (var fileStream = File.OpenRead(@"..\\NCache Introduction.mp4"))
    {
        // Use GetCacheStream to initialize CacheStream object by setting streamAttributes against the specified key
        using (var cacheStream = cache.GetCacheStream(key, streamAttributes))
        {
            // Create a byte array to read data in chunks of 4096 bytes
            byte[] dataToWrite = new byte[4096];
            long numBytesToRead = fileStream.Length;

            while (numBytesToRead > 0)
            {
                // Read chunk of data
                int bytesRead = fileStream.Read(dataToWrite, 0, dataToWrite.Length);

                // Break when the end of the file is reached
                if (bytesRead == 0)
                    break;

                // Write stream data to cache
                cacheStream.Write(dataToWrite, 0, bytesRead);
            }
        }
    }
}

catch (OperationFailedException ex)
{
    // Exception can occur due to:
    // Connection Failures
    // Operation Timeout
    // Operation performed during state transfer
}
catch (Exception ex)
{
    // handle exception
    // This includes StreamException
}

try 
{
    // Pre-condition: Cache is already connected
    // Generate a unique cache key
    int readByteCount = 0;
    byte[] readBuffer = new byte[5000];

    // Initialize CacheStream object
    CacheStream cacheStream = null;

    // Provide the StreamMode in CacheStreamAttributes object 
    CacheStreamAttributes cacheStreamAttributes = new CacheStreamAttributes(StreamMode.Write);
    //cacheStreamAttributes.setGroup();
    //cacheStreamAttributes.setExpiration();
    //cacheStreamAttributes.setCacheItemPriority();

    // Use GetCacheStream to set StreamAttributes against the specified key 
    using (CacheStream caceheStream = cache.getCacheStream(key, cacheStreamAttributes))
        {
            while (fs.CanRead)
            {
                var bytesRead = fileStream.read(buffer, 0, buffer.length);

                // Now write/store these bytes in the cache
                caceheStream.write(buffer, 0, bytesRead);

                bytesCount += bytesRead;
            }
        }
        Console.Writeline(key + " file content stored as CacheStream. Total bytes: " + bytesCount);

    // Close stream
    cacheStream.Close();
} 

catch (OperationFailedException exception) 
{
    // Exception can occur due to:
    // Connection Failures
    // Operation Timeout
    // Operation performed during state transfer
} 
catch (Exception exception) 
{
    // Generic exception like IllegalArgumentException or NullPointerException
}

Using GetBufferedStream

Buffered stream is the set of bytes used for storing the data up to the certain limit before reading or writing it to the cache. The following code shows how to use GetBufferedStream:

.NET/.NET Core
Java

    // Generate a unique cache key
    string key = "BufferedStreamKey";

    // Set StreamMode object to Write mode
    StreamMode streamMode = StreamMode.Write;

    // Provide the streamMode in CacheStreamAttributes object
    var streamAttributes = new CacheStreamAttributes(streamMode);

    // Data will be wriiten to cache once buffered data size reaches this limit
    int bufferLength = 4096;

    // Open stream to read video file
    using (var fileStream = File.OpenRead(@"..\\NCache Introduction.mp4"))
    {
         // Initialize CacheStream object by setting streamAttributes against the specified key and Get Buffered stream
        using (var cacheStream = cache.GetCacheStream(key, streamAttributes).GetBufferedStream(bufferLength))
        {
            // Create a byte array to read data
            byte[] dataToWrite = new byte[1024];
            long numBytesToRead = fileStream.Length;

            while (numBytesToRead > 0)
            {
                // Read file in chunks of 1024 bytes
                int bytesRead = fileStream.Read(dataToWrite, 0, dataToWrite.Length);

                // Break when the end of the file is reached.
                if (bytesRead == 0)
                    break;

                // Write data to stream buffer.
                // Buffered data will be witten to cache once it reache limit of 4096 bytes
                cacheStream.Write(dataToWrite, 0, bytesRead);
            }
        }
    }

try 
{
    // Precondition: cache is already connected

    // Generate a unique cache key

    String key = "StreamKey";

    // Set write mode for StreamMode object
    StreamMode streamMode = StreamMode.Write;

    // Provide the streamMode object to CacheStreamAttributes object
    CacheStreamAttributes streamAttributes = new CacheStreamAttributes(streamMode);

    // ReadAllBytes returns the stream from the provided path in a byte array
    Path path = FileSystems.getDefault().getPath("test", "test.txt");
    byte[] writeBuffer = Files.readAllBytes(path);

    // Set buffer length
    int length = writeBuffer.length;

    // Set GetBufferedStream property for cache stream
    BufferedOutputStream wStream = cache.getCacheStream(key, streamAttributes).getBufferedOutputStream(length);

    // Write data in buffer
    wStream.write(writeBuffer, 0, length);

    // Data is written in cache because buffer is full
    wStream.write(writeBuffer, length / 2, length / 2);

    // Close the stream
    wStream.close();
} 
catch (OperationFailedException exception) 
{
    // Exception can occur due to:
    // Connection Failures
    // Operation Timeout
    // Operation performed during state transfer
} 
catch (Exception exception) 
{
    // Generic exception like IllegalArgumentException or NullPointerException
}

Additional Resources

NCache provides sample application for streaming on GitHub.

Add/Update Cache Data with Streams

Prerequisites

Writing to a Stream

Using GetBufferedStream

Additional Resources

See Also