bakape/recache

recursive compressed caching library

recache's Issues

Benchmark against a classic Redis cache

• time.Sleep() for 500 ms on data generation to simulate DB queries
• 3 part document
  • Stored whole in Redis
  • Broken down in recache
• Key retrieval function for Redis versioning with time.Sleep() for 50 ms
• Evict/return new key each 5 seconds

Assert record pointer match on eviction checks

They might not, if an eviction and fetch happened while a record is populating.

Populate recursive components asynchronously

• If recordReference is not in the cache on query, schedule it to be fetched in a separate goroutine to not block retrieving any subsequent components.
• Add Await() error method to component interface, that blocks until a component is retrieved.
  • Block only for async recordReference retrieval.

Having a separate Await() method instead of returning errors on read allows for error to be propagated before the first write to destination.

Use a forward list for record components

Most records should have 1-3 components and thus not using arrays can prevent extra indirection. At the end of the struct can be an extension slice for records with more components.

Automatically decompress, if client does not indicate Deflate support in headers

Allow specifying custom GZIP strength on RecordWriter

Probably as a setter method. Default to default compression strength.

Horizontal scaling

• Need to asserts server version through some means and not communicate with instances of same version. Considering the variations possible both in the system and externally, a cache should have a manually set name and version. If not set, no horizontal scaling is performed.
• Consider, if static or dynamic sharding by hash is better.
• Consider, if this useful at all, considering the extra I/O costs. Opting for only vertical scaling might be more optimal.
• Consider how to handle a client requesting a key belonging to a foreign shard.

Rewrite in Rust

• Rewrite using Rust stdlib
• Leave thread/async management to the caller. The lib only acts as persistent linker layer.
• Provide C bindings and header file
  • Pass errors as void* to allow casting between language-idiomatic error types
• Rust implementation should take any generic parameter implementing Hash as a Frontend Key
• C bindings should only allow keys fixed format. Bindings should (en-)/(de-)code keys to/from this format .

  struct RecacheBufferKey 
  {
    size_t size;
    uint8_t *data;
  };

• Write Go bindings
  • Go bindings should use zero copy unsafe casts for buffers
  • Marshal and unmarshal keys using encoding/gob
    • Reuse the encoder on the frontend
• Compile optimized binaries for all supported architectures and distribute them with the project

Transform method on RecordWriter

To establish a parenthood relationship between records, but not include it in the output. That is, the child transforms the parent and outputs the result.

Server mode

Read config.json file on boot to configure the caches and frontends without requiring any Go programming.

Something like

[
  {
    "limits": {
     "memory": "100M",
     "last_used": "1m30s" 
    },
    "frontends": [
      "endpoint": {
        "url":  "/:company/:brand", // Join with delimiter and use that as a key
        "headers": {
           "Content-Type": "application/html"
         } 
      }
      "source": {
         "url": "http://localhost:8000/my-data-source",
         "headers": {
           "Authorization": "Bearer d4ea54de3a54d1d5ea1de"
         }
      }
    ]
  }
]

• Add sample to docs
• Add jsonc file with usage description to docs
• Add a simpler mode, where the server just acts as 1:1 proxy from one path to another