Scribbly.Cubby.MessagePack 0.1.0-24-http-client.1

Scribbly Cubby

A distributed caching service built on dotnet. You know take stuff out and put stuff away.
Cubby is a chose your own adventure caching service. Cubby can be used as a library hosted by your application or standalone as a Native AOT running on Linux, Windows, or containerized.

Table of Contents

• Scribbly Cubby
  • Table of Contents
  • Example
• Cubby Host
  • AOT
  • Library
  • Docker
  • Transports
    • HTTP
    • GRPC
    • TCP
• Cubby Client
  • Transports
    • HTTP
    • GRPC
    • TCP
  • Serializers
    • System.Text.Json
    • MessagePack
  • Compression
• Benchmarks
  • 2025.12.20 Store Comparisons

Example

Below is a brief snip of code to get you started before reading more.

Cubby Host

The cubby host is a native AOT application that can be hosted on bare metal or containers. Cubby host can also be used as a nuget package and executed from within an existing application.

AOT

Library

Add a package reference to Scribbly.Cubby.Server as well as a Transport package such as Scribbly.Cubby.Grpc.Server or Scribbly.Cubby.Http.Server

To get started some services need to be configured and registered.

var builder = WebApplication.CreateSlimBuilder(args);

// Use our defaults
builder.AddCubbyServer();

configure options

var builder = WebApplication.CreateSlimBuilder(args);

builder
    .AddCubbyServer(ops =>
    {
        // Cubby's default storage
        ops.Store = CubbyOptions.StoreType.RefStruct; 
        
        // When greater than zero a max cache key value will be set.  This is a large optimization if the value is known.
        ops.Capacity = int.MinValue;
        
        // Override the concurrency with a specific number of CORES
        ops.Cores = Environment.ProcessorCount;
    });

Once configured each transport may/will require some setup.

builder
    .AddCubbyServer()
    .WithCubbyGrpcServer();

Lastly the application may need to bind the transport

var builder = WebApplication.CreateSlimBuilder(args);

builder
    .AddCubbyServer()
    .WithCubbyGrpcServer();

var app = builder.Build();

app.MapCubbyGrpc();

Docker

Simply pull our container using docker pull.

docker pull scribbly/cubby:0.1.0-7-docker-file.2

Transports

Cubby (will) support multiple transports configured in the hosted application or using environment variables.

HTTP

GRPC

TCP

Cubby Client

Transports

HTTP

GRPC

TCP

Serializers

Cubby allows clients to create custom encoders or use pre-built serializers provided by cubby.

System.Text.Json

By default cubby will use System.Text.Json to serialize all object as byte[] data.

cubby implicitly uses System.Text.Json

builder.Services
    .AddCubbyClient()
    .WithCubbyGrpcClient();

override and configure the serializer

builder.Services
    .AddCubbyClient(ops =>
    {
        ops.AddSystemTextSerializer();
    })
    .WithCubbyGrpcClient();

extend and override our defaults

builder.Services
    .AddCubbyClient(ops =>
    {
        ops.AddSystemTextSerializer(ops =>
        {
            // Add type resolvers to ensure AOT compliance
            ops.TypeInfoResolverChain.Insert(0, ItemJsonContext.Default);
        });
    })
    .WithCubbyGrpcClient();

configure a compression service

builder.Services
    .AddCubbyClient(ops =>
    {
        ops.AddSystemTextSerializer(
            optionsCallback: ops =>
            {
                ops.TypeInfoResolverChain.Insert(0, ItemJsonContext.Default);
            }, 
            compressor: new MyCompressor());
    })
    .WithCubbyGrpcClient();

MessagePack

By adding a reference to the Scribbly.Cubby.MessagePack cubby con be configured to use MessagePack to serialize all objects.

https://github.com/MessagePack-CSharp/MessagePack-CSharp

call the AddMessagePackSerializer() method to use message pack

builder.Services
    .AddCubbyClient(ops =>
    {
        ops.AddMessagePackSerializer();
    })
    .WithCubbyGrpcClient();

override and configure the serializer

builder.Services
    .AddCubbyClient(ops =>
    {
        ops.AddMessagePackSerializer(ops =>
        {
            // See message pack docs
            ops.SequencePool.Clear();
        });
    })
    .WithCubbyGrpcClient();

Compression

Benchmarks

2025.12.20 Store Comparisons

The initial benchmarks to help select a default starting point for a in-memory caching mechanism