shimanism

module
v0.0.0-...-f90ee87 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jun 7, 2026 License: AGPL-3.0

README

shimanism

shimanism

Go Generated Tests Modules

storage secrets queue pubsub rdbms cache functions apigateway internal cmd peers

Reroute cloud services, one at a time.

shimanism is a translation proxy that speaks the cloud's own published API on the front and forwards each call to a real, comparable service somewhere else — another cloud, a Kubernetes operator, or a self-hosted server.

Keep your existing AWS code talking to "AWS"; transparently reroute, say, storage to GCS while everything else still uses real AWS; verify it works; reroute the next service; repeat. The shim is a stable on-ramp between clouds — no big-bang rewrite, no SDK swap, no Terraform-provider port.

Your code keeps using boto3, aws s3, gcloud storage, hashicorp/aws, the Azure SDK, or whatever else. You change one thing: the endpoint URL. The bytes land wherever the shim is pointed.

Nothing is reimplemented. Nothing is emulated. The data lives in a real backend.

See it in action

The same MinIO server, accessed three different ways via three different shim frontends:

AWS CLI:

aws --endpoint-url=http://localhost:9001 s3 mb s3://my-bucket
aws --endpoint-url=http://localhost:9001 s3 cp app.tar.gz s3://my-bucket/
aws --endpoint-url=http://localhost:9001 s3 ls s3://my-bucket/

gcloud CLI:

gcloud storage buckets create gs://my-bucket \
  --api-endpoint-overrides=storage=http://localhost:9002
gcloud storage cp app.tar.gz gs://my-bucket/ \
  --api-endpoint-overrides=storage=http://localhost:9002

Go SDK (AWS S3):

client := s3.NewFromConfig(aws.Config{
    Region:       "us-east-1",
    BaseEndpoint: aws.String("http://localhost:9001"),
})
_, err := client.PutObject(ctx, &s3.PutObjectInput{
    Bucket: aws.String("my-bucket"),
    Key:    aws.String("app.tar.gz"),
    Body:   strings.NewReader("..."),
})

Terraform (hashicorp/aws):

provider "aws" {
  region                      = "us-east-1"
  access_key                  = "test"
  secret_key                  = "test"
  skip_credentials_validation = true
  skip_metadata_api_check     = true
  skip_requesting_account_id  = true
  s3_use_path_style           = true

  endpoints {
    s3 = "http://localhost:9001"
  }
}

resource "aws_s3_bucket" "app" {
  bucket = "my-bucket"
}

All four examples produce a real bucket holding real bytes — in MinIO (or GCS, Azure Blob, real S3, etc., whichever backend the shim was started with). The clients don't know they're not talking to real S3 / real GCS.

See docs/getting-started.md for the five-minute walkthrough and docs/end-to-end-examples.md for real backend, optional simulator, SDK, CLI, and Terraform import examples.

Shimmed services

Service AWS GCP Azure Kubernetes Per-service docs
Object storage S3 Cloud Storage Blob Storage MinIO docs/services/storage.md
Secrets Secrets Manager Secret Manager Key Vault Vault docs/services/secrets.md
Queue SQS Pub/Sub (pull) Service Bus queue NATS JetStream docs/services/queue.md
Pub/sub SNS + SQS Pub/Sub Service Bus topics NATS docs/services/pubsub.md
Managed Postgres / MySQL (control plane) RDS Cloud SQL Azure DB Flexible Server CloudNativePG / MySQL Operator docs/services/rdbms.md
Managed Redis (control plane) ElastiCache Memorystore Azure Cache for Redis Redis Operator docs/services/cache.md
Functions (container image, control plane) Lambda Cloud Run Container Apps Knative docs/services/functions.md
API gateway API Gateway HTTP API v2 API Gateway API Management Envoy Gateway docs/services/apigateway.md
Container registry ECR Artifact Registry Container Registry CNCF Distribution docs/services/registry.md
Event streaming (in progress) MSK Managed Service for Apache Kafka Event Hubs Kafka endpoint Strimzi Kafka docs/services/eventstream.md

Managed databases and managed Redis: only the control plane is shimmed (provisioning, scaling, snapshots, access bindings). The data plane is wire-protocol Postgres / MySQL / RESP — connect directly to the returned host.

Why this works

Every shim is two layers:

  • Frontend: speaks the cloud's published API exactly (SigV4 + S3 XML; OAuth2 + GCP JSON; SharedKey + Azure REST; etc). The codegen pipeline (currently Smithy-only; see docs/codegen.md) produces server stubs from the upstream spec for storage; the other services compose the wire layer by hand using the cloud SDKs' wire-type packages directly. Migrating the rest to codegen is on the roadmap.
  • Backend: calls the real destination. AWS frontend over a GCS backend = AWS S3 wire on the front, real storage.googleapis.com on the back.

In between sits a neutral domain interface — the cross-cloud intersection of what every backend actually supports. Where a feature has no peer (S3 Object Lambda, Azure private endpoints, GCP-only retention), the shim returns the source cloud's own "not supported" error in its own vocabulary. Never a fabricated success. Never a silent fallback. See PHILOSOPHY.md for the why.

Goals

  • Shim cloud-locked managed services that publish strong, machine-readable APIs (OpenAPI, protobuf, ARM schema, Smithy).
  • Translate honestly between AWS, GCP, Azure, and a selected Kubernetes-native peer per service.
  • Stay transparent to existing SDKs, CLIs, and Terraform providers via their built-in endpoint-override.
  • Cover the intersection of functionality across all backends. Where a feature has no peer, fail loud in the source cloud's own error vocabulary.
  • Build the Kubernetes peer ourselves if no suitable open-source equivalent exists.

How shimanism differs from other projects

shimanism's niche: it lives at the wire-protocol layer, speaks the source cloud's exact API, and runs against real backends — not emulators, not its own API, not a single-cloud compatibility shim. The result is that the same aws, gcloud, boto3, Terraform module, or Pulumi provider works without modification while data moves between clouds.

The closest comparison points and how shimanism differs from each:

Project What it is How shimanism differs
LocalStack Local cloud emulator (AWS-shape; Pro adds Snowflake + others) for dev/test; state in-process or persisted to disk via the persistence module. shimanism is not an emulator. Data lives in real backends. Production migration is the use case; LocalStack is dev/test. The LocalStack-backed shimanism path is not tested yet.
MinIO, Cloudflare R2, Backblaze B2 S3-compatible backends. They implement the S3 wire on top of their own storage. shimanism is a frontend translation layer, not a backend. It can use MinIO as a backend; the value-add is the cross-cloud frontend matrix (gcloud → GCS frontend → MinIO; aws → S3 frontend → MinIO; etc.) and the other shimmed services beyond storage.
Crossplane Kubernetes CR-based control plane for multi-cloud infrastructure. Provider CRDs (managed resources) + composed XR abstractions via XRD + Composition. Crossplane requires you to stop using your cloud SDK / IaC provider and rewrite to its CRD model. shimanism lets you keep the original SDK (aws-sdk-go, boto3, @aws-sdk/*, cloud.google.com/go/..., Azure SDK) and the original IaC (hashicorp/aws, hashicorp/google, hashicorp/azurerm) — same calls, same plans, just pointed at a different endpoint. No new abstraction to learn, no per-resource CRD translation.
Dapr Distributed-app runtime with multi-cloud bindings for state, pub/sub, secrets, etc. Apps call the Dapr SDK/sidecar. Dapr requires you to rewrite to its API. shimanism lets you keep the cloud's API. Different target: Dapr is for greenfield apps that want portability; shimanism is for brownfield apps that need migration.
gocloud.dev / Apache Libcloud / Apache jclouds Neutral cloud-agnostic SDKs (Go / Python / JVM). Apps import the neutral library instead of the cloud SDK. Library-level abstraction — apps swap SDKs. shimanism keeps the cloud SDK; no library swap, any language.
Pulumi / Terraform / OpenTofu / AWS CDK Infrastructure-as-code with multi-cloud provider plugins. IaC tools, not data-plane proxies. They provision resources; they don't proxy runtime API calls. shimanism works with them — your Terraform / OpenTofu plan still uses hashicorp/aws, but the bytes land on GCS through the shim.
OpenStack Swift S3 middleware, Ceph RGW, Garage, NooBaa, s3proxy S3-compatible APIs on top of various storage backends. Single-frontend (S3), single-service (object storage) compat shims. shimanism spans multiple frontend shapes × multiple backends × multiple service families.

The mental model: shimanism is to rerouting cloud services one at a time what cross-compilation is to portable binaries. The application doesn't know the target changed; the platform layer below it absorbed the difference, honestly.

For deeper reading: PHILOSOPHY.md on the "intersection-only, never lie" stance; docs/architecture.md on the frontend/domain/backend layering; docs/cross-cloud-routing.md on the migration story end-to-end.

Non-goals

  • Not an emulator. shimanism does not reimplement services in-memory or on local disk. For local testing, shimanism has a maintained sockerless simulator lane; LocalStack may also be useful for AWS-shaped local development, but that path is not tested by this project yet.
  • Not a neutral SDK. There is no shimanism client library. Application code keeps importing boto3, @azure/storage-blob, google-cloud-pubsub, and so on.
  • Not a lowest-common-denominator abstraction layer. We honor the source cloud's API. Where a call cannot be translated honestly, it fails in the source cloud's own error vocabulary rather than being smoothed over.
  • Not a Terraform wrapper. Control-plane operations call the cloud admin APIs directly.
  • Not for services where redirection is already trivial. Postgres, MySQL, and Redis speak the same wire protocol everywhere; their data planes are not shimmed.
  • Not for services with fundamentally incompatible models across clouds, such as IAM and identity.
  • Not for layers already standardized by the industry: Kubernetes, OCI distribution, OpenTelemetry.

Maturity

shimanism is pre-1.0 and pre-production. The honest state per surface:

Surface Status
Service catalog The 8 services in the table above are wired end-to-end against inmem / local emulator backends.
inmem backend per service Works. Used for local dev + the conformance harness.
Local emulator backends (MinIO / NATS / Vault / kind + Knative / kind + Envoy Gateway / cnpg / Redis Operator) Work; exercised by per-backend conformance lanes in CI.
Cross-cloud terraform import (Phase 9) Works; TestCrossCloudImport_Roundtrip_* per service.
Cross-cloud terraform apply (Phase 10) Storage exit criterion green (TestCrossCloudApply_Roundtrip_StorageAWStoGCS); other services have documented-skip cross-cloud cells with per-cell asymmetry rationale (real cloud-API mismatches, not shim bugs).
Real-cloud backends (passthrough to actual AWS / GCP / Azure accounts) Gated on "Track A" — cloud test accounts. Not yet exercised in CI.
Request signature verification (SigV4 / OAuth2 / SharedKey) Not implemented yet — see BUG-18. The shim accepts unsigned requests today. Do not expose to untrusted traffic until BUG-18 closes.
Codegen pipeline Smithy-only (cmd/codegen); only storage has generated stubs today. Other services compose their wire layer by hand using the cloud SDKs' wire-type packages. See docs/codegen.md.

The full bug ledger lives in BUGS.md.

Code architecture and how the build works

If you just cloned the repo, here is the orientation in 60 seconds.

Layout. One Go module, three structural buckets:

  • cmd/ — entry points. cmd/shim is the actual server you run. cmd/codegen, cmd/azure-codegen, cmd/gcp-codegen are spec→code generators that produce the files under services/<svc>/gen/. cmd/inject-provenance stamps every vendored spec with a _provenance key so CI can detect spec drift.
  • internal/<svc>/ — the frontend (wire decode/encode + per-cloud quirks) and the domain interface for each shimmed service. The frontends call the domain; the domain has no knowledge of any backend.
  • services/<svc>/ — the spec vendored from upstream (spec/), the generated server stubs and types (gen/), the backends that translate domain calls into the destination cloud's SDK (backends/aws, backends/gcs, backends/azureblob, backends/inmem, plus the K8s peer where applicable), and the conformance tests that drive every (frontend × driver × backend) cell.

The K8s peer framework lives at peers/shimakit/ (its own Go module). Cross-shim machinery — auth verifiers, AWS protocol routers (awsjson, awsquery, restxml), client-config helpers — lives under internal/.

Minimal common footprint. Every shimmed service reduces to one tiny Go interface — the cross-cloud intersection of what AWS, GCP, Azure, and the K8s peer all support. The whole catalog adds up to 75 methods total across 8 services:

Service Domain interface Methods
storage domain.Storage 16
queue domain.Queues 12
pubsub domain.Pubsub 12
rdbms domain.RDBMS 11
secrets domain.Secrets 8
cache domain.Cache 6
functions domain.Functions 5
apigateway domain.APIGateway 5

Frontends collectively implement hundreds of cloud-specific wire operations (ListObjectsV2, GetBucketLifecycleConfiguration, …); backends implement at most these handfuls. That asymmetry is the whole point — the per-cloud surface area is huge, the cross-cloud intersection is small, and everything that doesn't fit the intersection fails loud in the source cloud's own error vocabulary.

Spec → code (the unusual bit). shimanism does not hand-write the wire layer for each cloud. Three codegen lanes, all wired through make codegen, walk vendored specs and emit Go:

  • AWS Smithy → custom emitter (cmd/codegen). Smithy has no official server-side Go generator, so the emitter is in-house; it handles all four AWS protocols (REST-XML, awsJson1.0/1.1, awsQuery, restJson1). Generated stubs land in services/<svc>/gen/.
  • Azure OpenAPI v2 → 8-stage preprocessor + oapi-codegen (cmd/azure-codegen). The preprocessor flattens ARM idioms (x-ms-paths, x-ms-enum, external $ref, allOf) into something oapi-codegen can consume.
  • GCP Discovery → routing-only emitter (cmd/gcp-codegen). Wire types are reused from google.golang.org/api/<svc>/v1 — Discovery → Go structs is already solved upstream. Our emitter only produces the dispatch layer.

What's hand-written is the per-backend translate.go files (one per operation) that map the generated request shapes into the destination cloud's SDK call, and a per-frontend adapter.go that glues the generated server stubs to the domain interface. That keeps the spec the source of truth: when upstream changes the spec, make codegen produces a diff and only the translation table needs human eyes. make codegen-check (also run by CI) enforces that committed gen output matches what the spec produces today.

Start at docs/architecture.md for the layer diagram and the full code-layout map, then docs/codegen.md for the spec-to-running-handler walkthrough.

Documentation

The repo root keeps a small set of load-bearing files. Everything else lives under docs/.

  • docs/ — the documentation index. Start here for setup, architecture, contributing, testing, codegen, releasing, and per-service detail.
  • docs/end-to-end-examples.md — start from real cloud credentials or an optional local simulator, then drive the shim with CLI, SDK, and Terraform provider endpoints.
  • PHILOSOPHY.md — the why every contributor should read before changing code.
  • AGENTS.md — rules for human and LLM contributors. The continuity contract, the no-fakes rule, the bug-first rule, branch + PR hygiene.
  • PLAN.md — phase roadmap and exit criteria.
  • STATUS.md · DO_NEXT.md · WHAT_WE_DID.md · BUGS.md — the four continuity files that carry the project across sessions.

License

AGPL-3.0.

Directories

Path Synopsis
cmd
azure-codegen command
Command azure-codegen reads an Azure OpenAPI v2 (Swagger) JSON spec, converts it to OpenAPI v3 in memory, and runs `oapi-codegen` as a library to emit Go types + std-net-http server stubs.
Command azure-codegen reads an Azure OpenAPI v2 (Swagger) JSON spec, converts it to OpenAPI v3 in memory, and runs `oapi-codegen` as a library to emit Go types + std-net-http server stubs.
codegen command
Command codegen reads a Smithy 2.0 JSON model and emits Go source for shimanism's HTTP handlers + request/response types for a specified set of operations.
Command codegen reads a Smithy 2.0 JSON model and emits Go source for shimanism's HTTP handlers + request/response types for a specified set of operations.
gcp-codegen command
Command gcp-codegen reads a Google API Discovery JSON document and emits Go source describing the service's HTTP routes — `(httpMethod, uriPattern, operationID)` triples that downstream GCP frontends use to drive their dispatch tables.
Command gcp-codegen reads a Google API Discovery JSON document and emits Go source describing the service's HTTP routes — `(httpMethod, uriPattern, operationID)` triples that downstream GCP frontends use to drive their dispatch tables.
inject-provenance command
Command inject-provenance reads a services/<svc>/spec/SOURCES.md table and rewrites every referenced JSON file to carry a top-level `_provenance` key documenting its upstream repo + path + pinned SHA (or Discovery revision) + license + fetched timestamp.
Command inject-provenance reads a services/<svc>/spec/SOURCES.md table and rewrites every referenced JSON file to carry a top-level `_provenance` key documenting its upstream repo + path + pinned SHA (or Discovery revision) + license + fetched timestamp.
shim command
Command shim is the entry point for the shimanism protocol-translation proxy.
Command shim is the entry point for the shimanism protocol-translation proxy.
shimctl command
Command shimctl is the operator-facing companion CLI to `shim`.
Command shimctl is the operator-facing companion CLI to `shim`.
internal
apigateway/domain
Package domain holds shimanism's neutral API Gateway control-plane interface and types.
Package domain holds shimanism's neutral API Gateway control-plane interface and types.
apigateway/frontends/aws_apigatewayv2
Package aws_apigatewayv2 is the AWS API Gateway HTTP API v2-shaped HTTP frontend.
Package aws_apigatewayv2 is the AWS API Gateway HTTP API v2-shaped HTTP frontend.
apigateway/frontends/azure_apim
Package azure_apim is the Azure API Management REST frontend.
Package azure_apim is the Azure API Management REST frontend.
apigateway/frontends/gcp_apigateway
Package gcp_apigateway is the GCP API Gateway REST/JSON frontend.
Package gcp_apigateway is the GCP API Gateway REST/JSON frontend.
awsjson
Package awsjson is the runtime helper for shimanism handlers generated against AWS Smithy services that use the awsJson1_0 or awsJson1_1 protocol — one HTTP endpoint (`POST /`), dispatch by the `X-Amz-Target: <Service>.<Operation>` header, JSON request and response bodies, JSON error envelopes with the `__type` field.
Package awsjson is the runtime helper for shimanism handlers generated against AWS Smithy services that use the awsJson1_0 or awsJson1_1 protocol — one HTTP endpoint (`POST /`), dispatch by the `X-Amz-Target: <Service>.<Operation>` header, JSON request and response bodies, JSON error envelopes with the `__type` field.
awsquery
Package awsquery is the runtime helper for shimanism handlers generated against AWS Smithy services that use the awsQuery protocol — one HTTP endpoint (POST /) with a `application/x-www-form-urlencoded` request body whose `Action` field carries the operation name, and XML responses wrapped in `<OpResponse><OpResult>...</OpResult><ResponseMetadata><RequestId>...
Package awsquery is the runtime helper for shimanism handlers generated against AWS Smithy services that use the awsQuery protocol — one HTTP endpoint (POST /) with a `application/x-www-form-urlencoded` request body whose `Action` field carries the operation name, and XML responses wrapped in `<OpResponse><OpResult>...</OpResult><ResponseMetadata><RequestId>...
azurebearer
Package azurebearer implements the Azure-side Bearer token verifier for shimanism's Azure-shaped frontends (Key Vault, Service Bus, ARM management surfaces).
Package azurebearer implements the Azure-side Bearer token verifier for shimanism's Azure-shaped frontends (Key Vault, Service Bus, ARM management surfaces).
azuresharedkey
Package azuresharedkey implements the Azure Storage SharedKey signature verifier.
Package azuresharedkey implements the Azure Storage SharedKey signature verifier.
cache/domain
Package domain holds shimanism's neutral cache (Redis) control-plane interface and types.
Package domain holds shimanism's neutral cache (Redis) control-plane interface and types.
cache/frontends/aws_elasticache
Package aws_elasticache is the AWS ElastiCache frontend for shimanism's cache service.
Package aws_elasticache is the AWS ElastiCache frontend for shimanism's cache service.
cache/frontends/azure_redis
Package azure_redis is the Azure Cache for Redis ARM frontend.
Package azure_redis is the Azure Cache for Redis ARM frontend.
cache/frontends/gcp_memorystore
Package gcp_memorystore is the GCP Memorystore-shaped REST/JSON frontend for shimanism's cache service.
Package gcp_memorystore is the GCP Memorystore-shaped REST/JSON frontend for shimanism's cache service.
clientconfig
Package clientconfig holds the per-(frontend, service) endpoint- override knobs that `shimctl env` emits.
Package clientconfig holds the per-(frontend, service) endpoint- override knobs that `shimctl env` emits.
codegen/emit
Package emit walks a Smithy model and emits Go source — request / response types, Backend interfaces, and HTTP handlers — for one or more operations.
Package emit walks a Smithy model and emits Go source — request / response types, Backend interfaces, and HTTP handlers — for one or more operations.
codegen/smithy
Package smithy parses a Smithy 2.0 JSON AST into Go types and supports the subset of Smithy needed by shimanism's codegen: all shape kinds (operation, service, structure, list, set, map, union, enum, intEnum, primitive types), and the traits used for HTTP binding, XML serialization, error responses, required-ness, timestamp formats, and AWS protocol selection.
Package smithy parses a Smithy 2.0 JSON AST into Go types and supports the subset of Smithy needed by shimanism's codegen: all shape kinds (operation, service, structure, list, set, map, union, enum, intEnum, primitive types), and the traits used for HTTP binding, XML serialization, error responses, required-ness, timestamp formats, and AWS protocol selection.
compute/domain
Package domain — instances.go covers Phase 16.C: compute instance lifecycle interface and types (neutral across AWS EC2, GCP Compute Engine, Azure Compute, and K8s Nodes).
Package domain — instances.go covers Phase 16.C: compute instance lifecycle interface and types (neutral across AWS EC2, GCP Compute Engine, Azure Compute, and K8s Nodes).
compute/frontends/aws_ec2
Package aws_ec2 is the AWS EC2 frontend for shimanism's compute service (Phase 16.B networking + Phase 16.C instance lifecycle + Phase 17 block storage).
Package aws_ec2 is the AWS EC2 frontend for shimanism's compute service (Phase 16.B networking + Phase 16.C instance lifecycle + Phase 17 block storage).
compute/frontends/azure_compute
Package azure_compute is the Azure Compute ARM frontend for shimanism's compute service (Phase 16.C instance lifecycle).
Package azure_compute is the Azure Compute ARM frontend for shimanism's compute service (Phase 16.C instance lifecycle).
compute/frontends/azure_network
Package azure_network is the Azure Network ARM frontend for shimanism's compute service, Phase 16.B (networking primitives).
Package azure_network is the Azure Network ARM frontend for shimanism's compute service, Phase 16.B (networking primitives).
compute/frontends/gcp_compute
Package gcp_compute is the GCP Compute Engine v1 frontend for shimanism's compute service.
Package gcp_compute is the GCP Compute Engine v1 frontend for shimanism's compute service.
dns/domain
Package domain holds shimanism's neutral DNS interface and types.
Package domain holds shimanism's neutral DNS interface and types.
dns/frontends/aws_route53
Package aws_route53 is the AWS Route 53 frontend adapter.
Package aws_route53 is the AWS Route 53 frontend adapter.
dns/frontends/azure_dns
Package azure_dns is the Azure DNS + Azure Private DNS ARM REST frontend for shimanism's DNS service.
Package azure_dns is the Azure DNS + Azure Private DNS ARM REST frontend for shimanism's DNS service.
dns/frontends/gcp_clouddns
Package gcp_clouddns is the GCP Cloud DNS REST/JSON frontend for shimanism's DNS service.
Package gcp_clouddns is the GCP Cloud DNS REST/JSON frontend for shimanism's DNS service.
ec2query
Package ec2query is the runtime helper for shimanism handlers generated against AWS Smithy services that use the ec2Query protocol — one HTTP endpoint (POST /) with an `application/x-www-form-urlencoded` request body whose `Action` field carries the operation name, and XML responses wrapped in `<OpNameResponse xmlns="..."><requestId>...</requestId>...fields...
Package ec2query is the runtime helper for shimanism handlers generated against AWS Smithy services that use the ec2Query protocol — one HTTP endpoint (POST /) with an `application/x-www-form-urlencoded` request body whose `Action` field carries the operation name, and XML responses wrapped in `<OpNameResponse xmlns="..."><requestId>...</requestId>...fields...
eventstream/domain
Package domain holds shimanism's neutral event-streaming interface.
Package domain holds shimanism's neutral event-streaming interface.
eventstream/frontends/aws_msk
Package aws_msk is the AWS MSK-shaped control-plane frontend for shimanism's eventstream service.
Package aws_msk is the AWS MSK-shaped control-plane frontend for shimanism's eventstream service.
eventstream/frontends/azure_eventhubs
Package azure_eventhubs is the Azure Event Hubs ARM control-plane frontend for shimanism's eventstream service.
Package azure_eventhubs is the Azure Event Hubs ARM control-plane frontend for shimanism's eventstream service.
eventstream/frontends/gcp_managedkafka
Package gcp_managedkafka is the GCP Managed Service for Apache Kafka REST/JSON control-plane frontend for shimanism's eventstream service.
Package gcp_managedkafka is the GCP Managed Service for Apache Kafka REST/JSON control-plane frontend for shimanism's eventstream service.
eventstream/kafkaserver
Package kafkaserver maps Kafka TCP requests onto the neutral event-stream domain backend.
Package kafkaserver maps Kafka TCP requests onto the neutral event-stream domain backend.
eventstream/kafkawire
Package kafkawire handles Kafka TCP frame boundaries and generated protocol request/response bodies for the event-streaming frontends.
Package kafkawire handles Kafka TCP frame boundaries and generated protocol request/response bodies for the event-streaming frontends.
functions/domain
Package domain holds shimanism's neutral functions control-plane interface.
Package domain holds shimanism's neutral functions control-plane interface.
functions/frontends/aws_lambda
Package aws_lambda is the AWS Lambda-shaped HTTP frontend.
Package aws_lambda is the AWS Lambda-shaped HTTP frontend.
functions/frontends/azure_containerapps
Package azure_containerapps is the Azure Container Apps ARM frontend.
Package azure_containerapps is the Azure Container Apps ARM frontend.
functions/frontends/gcp_cloudrun
Package gcp_cloudrun is the GCP Cloud Run-shaped REST/JSON frontend.
Package gcp_cloudrun is the GCP Cloud Run-shaped REST/JSON frontend.
gcpbearer
Package gcpbearer implements the GCP-side bearer-token verifier for shimanism's GCP-shaped frontends (Cloud Storage, Secret Manager, Pub/Sub, Cloud SQL Admin, Memorystore, Cloud Run, API Gateway).
Package gcpbearer implements the GCP-side bearer-token verifier for shimanism's GCP-shaped frontends (Cloud Storage, Secret Manager, Pub/Sub, Cloud SQL Admin, Memorystore, Cloud Run, API Gateway).
harness
Package harness provides test-only fixtures for spinning up a real shimanism shim instance with a chosen backend, addressable over HTTP so external clients (aws-sdk-go-v2, aws-cli, Terraform AWS provider, etc.) can drive it through their standard endpoint-override paths.
Package harness provides test-only fixtures for spinning up a real shimanism shim instance with a chosen backend, addressable over HTTP so external clients (aws-sdk-go-v2, aws-cli, Terraform AWS provider, etc.) can drive it through their standard endpoint-override paths.
kms/domain
Package domain holds shimanism's neutral key-management interface and types — the lingua franca between three frontend protocols (AWS KMS, GCP Cloud KMS, Azure Key Vault keys) and four backends (the three clouds + a K8s peer).
Package domain holds shimanism's neutral key-management interface and types — the lingua franca between three frontend protocols (AWS KMS, GCP Cloud KMS, Azure Key Vault keys) and four backends (the three clouds + a K8s peer).
kms/frontends/aws_kms
Package aws_kms is the AWS KMS frontend for shimanism's key-management service (Phase 19).
Package aws_kms is the AWS KMS frontend for shimanism's key-management service (Phase 19).
kms/frontends/azure_keyvault_keys
Package azure_keyvault_keys is the Azure Key Vault keys data-plane frontend for shimanism's key-management service (Phase 19).
Package azure_keyvault_keys is the Azure Key Vault keys data-plane frontend for shimanism's key-management service (Phase 19).
kms/frontends/gcp_cloudkms
Package gcp_cloudkms is the GCP Cloud KMS frontend for shimanism's key-management service (Phase 19).
Package gcp_cloudkms is the GCP Cloud KMS frontend for shimanism's key-management service (Phase 19).
loadbalancer/domain
Package domain holds shimanism's neutral load-balancer interface and types.
Package domain holds shimanism's neutral load-balancer interface and types.
loadbalancer/frontends/aws_elbv2
Package aws_elbv2 is the AWS ELBv2 frontend for shimanism's load balancer service.
Package aws_elbv2 is the AWS ELBv2 frontend for shimanism's load balancer service.
loadbalancer/frontends/azure_lb
Package azure_lb is the Azure Network load balancer ARM frontend for shimanism's load balancer service (Phase 16.D).
Package azure_lb is the Azure Network load balancer ARM frontend for shimanism's load balancer service (Phase 16.D).
loadbalancer/frontends/gcp_lb
Package gcp_lb is the GCP Compute Engine load balancer frontend for shimanism's load balancer service.
Package gcp_lb is the GCP Compute Engine load balancer frontend for shimanism's load balancer service.
nosql/domain
Package domain holds shimanism's neutral NoSQL key-value interface and types.
Package domain holds shimanism's neutral NoSQL key-value interface and types.
nosql/frontends/aws_dynamodb
Package aws_dynamodb is the AWS DynamoDB frontend adapter for shimanism's NoSQL service.
Package aws_dynamodb is the AWS DynamoDB frontend adapter for shimanism's NoSQL service.
nosql/frontends/azure_cosmos_tables
Package azure_cosmos_tables is the Azure Cosmos DB Table API frontend for shimanism's NoSQL service.
Package azure_cosmos_tables is the Azure Cosmos DB Table API frontend for shimanism's NoSQL service.
nosql/frontends/gcp_firestore
Package gcp_firestore is the GCP Firestore Native REST/JSON frontend for shimanism's NoSQL service.
Package gcp_firestore is the GCP Firestore Native REST/JSON frontend for shimanism's NoSQL service.
pubsub/domain
Package domain holds shimanism's neutral pub/sub interface and types.
Package domain holds shimanism's neutral pub/sub interface and types.
pubsub/frontends/aws_sns
Package aws_sns is the AWS SNS frontend for shimanism's pubsub service.
Package aws_sns is the AWS SNS frontend for shimanism's pubsub service.
pubsub/frontends/aws_sqs_receive
Package aws_sqs_receive is the SQS-shaped receive surface for shimanism's pubsub service.
Package aws_sqs_receive is the SQS-shaped receive surface for shimanism's pubsub service.
pubsub/frontends/azure_servicebus_topics
Package azure_servicebus_topics is the Azure Service Bus topics REST data-plane frontend for shimanism's pubsub service.
Package azure_servicebus_topics is the Azure Service Bus topics REST data-plane frontend for shimanism's pubsub service.
pubsub/frontends/gcp_pubsub
Package gcp_pubsub is the GCP Pub/Sub REST/JSON frontend for shimanism's pubsub service.
Package gcp_pubsub is the GCP Pub/Sub REST/JSON frontend for shimanism's pubsub service.
queue/domain
Package domain holds shimanism's neutral queue interface and types.
Package domain holds shimanism's neutral queue interface and types.
queue/frontends/aws_sqs
Package aws_sqs is the AWS SQS frontend for shimanism's queue service.
Package aws_sqs is the AWS SQS frontend for shimanism's queue service.
queue/frontends/azure_servicebus
Package azure_servicebus is the Azure Service Bus queues REST data-plane frontend for shimanism's queue service.
Package azure_servicebus is the Azure Service Bus queues REST data-plane frontend for shimanism's queue service.
queue/frontends/gcp_pubsub
Package gcp_pubsub is the GCP Pub/Sub REST/JSON frontend for shimanism's queue service.
Package gcp_pubsub is the GCP Pub/Sub REST/JSON frontend for shimanism's queue service.
rdbms/domain
Package domain holds shimanism's neutral RDBMS control-plane interface and types.
Package domain holds shimanism's neutral RDBMS control-plane interface and types.
rdbms/frontends/aws_rds
Package aws_rds is the AWS RDS frontend for shimanism's rdbms service.
Package aws_rds is the AWS RDS frontend for shimanism's rdbms service.
rdbms/frontends/azure_dbadmin
Package azure_dbadmin is the Azure DB Admin (PostgreSQL Flexible Server) ARM frontend.
Package azure_dbadmin is the Azure DB Admin (PostgreSQL Flexible Server) ARM frontend.
rdbms/frontends/gcp_cloudsql
Package gcp_cloudsql is the GCP Cloud SQL Admin REST/JSON frontend for shimanism's rdbms service.
Package gcp_cloudsql is the GCP Cloud SQL Admin REST/JSON frontend for shimanism's rdbms service.
registry/domain
Package domain holds shimanism's neutral container-registry interface and types — the lingua franca between three frontend protocols (AWS ECR, GCP Artifact Registry, Azure ACR) and four backends (the three clouds + the CNCF distribution K8s peer).
Package domain holds shimanism's neutral container-registry interface and types — the lingua franca between three frontend protocols (AWS ECR, GCP Artifact Registry, Azure ACR) and four backends (the three clouds + the CNCF distribution K8s peer).
registry/frontends/aws_ecr
Package aws_ecr is the AWS Elastic Container Registry frontend for shimanism's container-registry service (Phase 18).
Package aws_ecr is the AWS Elastic Container Registry frontend for shimanism's container-registry service (Phase 18).
registry/frontends/azure_acr
Package azure_acr is the Azure Container Registry frontend for shimanism's container-registry service.
Package azure_acr is the Azure Container Registry frontend for shimanism's container-registry service.
registry/frontends/gcp_artifactregistry
Package gcp_artifactregistry is the GCP Artifact Registry frontend for shimanism's container-registry service (Phase 18).
Package gcp_artifactregistry is the GCP Artifact Registry frontend for shimanism's container-registry service (Phase 18).
registry/ocidistribution
Package ocidistribution is shimanism's hand-written OCI Distribution Spec v1 (/v2/) data-plane router.
Package ocidistribution is shimanism's hand-written OCI Distribution Spec v1 (/v2/) data-plane router.
restxml
Package restxml is the runtime support library that shimanism's generated REST-XML handlers (AWS S3, Route 53, CloudFront, etc.) call into.
Package restxml is the runtime support library that shimanism's generated REST-XML handlers (AWS S3, Route 53, CloudFront, etc.) call into.
secrets/domain
Package domain holds shimanism's neutral secrets interface and types.
Package domain holds shimanism's neutral secrets interface and types.
secrets/frontends/aws_secretsmanager
Package aws_secretsmanager is the AWS Secrets Manager frontend for shimanism's secrets service.
Package aws_secretsmanager is the AWS Secrets Manager frontend for shimanism's secrets service.
secrets/frontends/azure_keyvault
Package azure_keyvault is the Azure Key Vault secrets-surface REST/JSON frontend.
Package azure_keyvault is the Azure Key Vault secrets-surface REST/JSON frontend.
secrets/frontends/gcp_secretmanager
Package gcp_secretmanager is the GCP Secret Manager REST/JSON frontend for shimanism's secrets service.
Package gcp_secretmanager is the GCP Secret Manager REST/JSON frontend for shimanism's secrets service.
sigv4verifier
Package sigv4verifier implements the server-side SigV4 verifier shimanism needs to reject unsigned / tampered-signature requests with the source cloud's own 401/403 envelope.
Package sigv4verifier implements the server-side SigV4 verifier shimanism needs to reject unsigned / tampered-signature requests with the source cloud's own 401/403 envelope.
storage/domain
Package domain holds shimanism's neutral object-storage interface and types.
Package domain holds shimanism's neutral object-storage interface and types.
storage/frontends/aws_s3
Package aws_s3 is the AWS S3 frontend adapter.
Package aws_s3 is the AWS S3 frontend adapter.
storage/frontends/azure_blob
Package azure_blob is the Azure Blob Storage REST API frontend.
Package azure_blob is the Azure Blob Storage REST API frontend.
storage/frontends/gcs
Package gcs is the GCS REST API frontend for shimanism's storage service.
Package gcs is the GCS REST API frontend for shimanism's storage service.
services
apigateway/backends/aws
Package aws is the AWS API Gateway v2 passthrough backend.
Package aws is the AWS API Gateway v2 passthrough backend.
apigateway/backends/azure
Package azure is the Azure API Management backend.
Package azure is the Azure API Management backend.
apigateway/backends/envoy
Package envoy is the Envoy Gateway backend for shimanism's API Gateway service, acting as the K8s peer.
Package envoy is the Envoy Gateway backend for shimanism's API Gateway service, acting as the K8s peer.
apigateway/backends/gcp
Package gcp is the GCP API Gateway backend.
Package gcp is the GCP API Gateway backend.
apigateway/backends/inmem
Package inmem is an in-process API Gateway backend.
Package inmem is an in-process API Gateway backend.
apigateway/conformance
Package conformance hosts the backend factories used by the parameterised matrix tests in this directory.
Package conformance hosts the backend factories used by the parameterised matrix tests in this directory.
cache/backends/aws
Package aws is the AWS ElastiCache passthrough backend.
Package aws is the AWS ElastiCache passthrough backend.
cache/backends/azure
Package azure is the Azure Cache for Redis backend.
Package azure is the Azure Cache for Redis backend.
cache/backends/gcp
Package gcp is the GCP Memorystore for Redis backend.
Package gcp is the GCP Memorystore for Redis backend.
cache/backends/inmem
Package inmem is an in-process cache backend used by the conformance harness as the always-on baseline.
Package inmem is an in-process cache backend used by the conformance harness as the always-on baseline.
cache/backends/redisop
Package redisop is the Redis Operator backend for shimanism's cache service, acting as the K8s peer.
Package redisop is the Redis Operator backend for shimanism's cache service, acting as the K8s peer.
cache/conformance
Package conformance hosts the backend factories used by the parameterised cache conformance tests.
Package conformance hosts the backend factories used by the parameterised cache conformance tests.
compute/backends/aws
Package aws is the AWS EC2 passthrough backend for shimanism's compute service (Phase 16.B networking primitives).
Package aws is the AWS EC2 passthrough backend for shimanism's compute service (Phase 16.B networking primitives).
compute/backends/azure
Package azure is the Azure Network passthrough backend for shimanism's compute service (Phase 16.B networking primitives).
Package azure is the Azure Network passthrough backend for shimanism's compute service (Phase 16.B networking primitives).
compute/backends/gcp
Package gcp is the GCP Compute Engine passthrough backend for shimanism's compute service (Phase 16.B networking primitives).
Package gcp is the GCP Compute Engine passthrough backend for shimanism's compute service (Phase 16.B networking primitives).
compute/backends/inmem
Package inmem provides an in-memory networking backend for tests.
Package inmem provides an in-memory networking backend for tests.
compute/backends/k8scompute
Package k8scompute is the Kubernetes peer for shimanism's compute service networking primitives, Phase 16.B.
Package k8scompute is the Kubernetes peer for shimanism's compute service networking primitives, Phase 16.B.
dns/backends/aws
Package aws is the AWS Route 53 passthrough backend.
Package aws is the AWS Route 53 passthrough backend.
dns/backends/azure
Package azure is the Azure DNS + Private DNS passthrough backend.
Package azure is the Azure DNS + Private DNS passthrough backend.
dns/backends/coredns
Package coredns is shimanism's K8s peer for DNS: a file-based backend that materializes zone state as RFC 1035 master files in a configured directory.
Package coredns is shimanism's K8s peer for DNS: a file-based backend that materializes zone state as RFC 1035 master files in a configured directory.
dns/backends/gcp
Package gcp is the GCP Cloud DNS passthrough backend.
Package gcp is the GCP Cloud DNS passthrough backend.
dns/backends/inmem
Package inmem provides an in-memory DNS backend for tests.
Package inmem provides an in-memory DNS backend for tests.
eventstream/backends/inmem
Package inmem is an in-process event-stream backend for tests.
Package inmem is an in-process event-stream backend for tests.
eventstream/backends/strimzi
Package strimzi is the Strimzi Kafka Operator K8s peer for shimanism's eventstream service (Phase 20.D).
Package strimzi is the Strimzi Kafka Operator K8s peer for shimanism's eventstream service (Phase 20.D).
functions/backends/aws
Package aws is the AWS Lambda passthrough backend.
Package aws is the AWS Lambda passthrough backend.
functions/backends/azure
Package azure is the Azure Container Apps passthrough backend.
Package azure is the Azure Container Apps passthrough backend.
functions/backends/gcp
Package gcp is the GCP Cloud Run passthrough backend.
Package gcp is the GCP Cloud Run passthrough backend.
functions/backends/inmem
Package inmem is an in-process functions backend used by the conformance harness as the always-on baseline.
Package inmem is an in-process functions backend used by the conformance harness as the always-on baseline.
functions/backends/knative
Package knative is the Knative Serving backend for shimanism's functions service, acting as the K8s peer.
Package knative is the Knative Serving backend for shimanism's functions service, acting as the K8s peer.
functions/conformance
Package conformance hosts the backend factories.
Package conformance hosts the backend factories.
kms/backends/aws
Package aws is the AWS KMS passthrough backend for shimanism's key-management service (Phase 19).
Package aws is the AWS KMS passthrough backend for shimanism's key-management service (Phase 19).
kms/backends/azure
Package azure is the Azure Key Vault keys passthrough backend for shimanism's key-management service (Phase 19).
Package azure is the Azure Key Vault keys passthrough backend for shimanism's key-management service (Phase 19).
kms/backends/gcp
Package gcp is the GCP Cloud KMS passthrough backend for shimanism's key-management service (Phase 19).
Package gcp is the GCP Cloud KMS passthrough backend for shimanism's key-management service (Phase 19).
kms/backends/inmem
Package inmem is an in-memory KMS backend for tests.
Package inmem is an in-memory KMS backend for tests.
loadbalancer/backends/aws
Package aws is the AWS ELBv2 passthrough backend for shimanism's load balancer service (Phase 16.D).
Package aws is the AWS ELBv2 passthrough backend for shimanism's load balancer service (Phase 16.D).
loadbalancer/backends/inmem
Package inmem provides an in-memory load balancer backend for tests.
Package inmem provides an in-memory load balancer backend for tests.
loadbalancer/backends/k8slb
Package k8slb is the Kubernetes peer for shimanism's load balancer service (Phase 16.D + Phase 21.C).
Package k8slb is the Kubernetes peer for shimanism's load balancer service (Phase 16.D + Phase 21.C).
nosql/backends/aws
Package aws is the AWS DynamoDB passthrough backend.
Package aws is the AWS DynamoDB passthrough backend.
nosql/backends/azure
Package azure is the Azure Cosmos DB Table API passthrough backend.
Package azure is the Azure Cosmos DB Table API passthrough backend.
nosql/backends/etcd
Package etcd is shimanism's K8s peer for NoSQL: an etcd-backed implementation of domain.NoSQL, the canonical "fourth backend" per AGENTS.md's "Kubernetes is the fourth backend, always" rule.
Package etcd is shimanism's K8s peer for NoSQL: an etcd-backed implementation of domain.NoSQL, the canonical "fourth backend" per AGENTS.md's "Kubernetes is the fourth backend, always" rule.
nosql/backends/gcp
Package gcp is the GCP Firestore Native passthrough backend.
Package gcp is the GCP Firestore Native passthrough backend.
nosql/backends/inmem
Package inmem provides an in-memory NoSQL backend for tests.
Package inmem provides an in-memory NoSQL backend for tests.
pubsub/backends/aws
Package aws is the AWS SNS+SQS passthrough backend for shimanism's pubsub service.
Package aws is the AWS SNS+SQS passthrough backend for shimanism's pubsub service.
pubsub/backends/azure
Package azure is the Azure Service Bus topics backend for shimanism's pubsub service.
Package azure is the Azure Service Bus topics backend for shimanism's pubsub service.
pubsub/backends/gcp
Package gcp is the GCP Pub/Sub fanout backend for shimanism's pubsub service.
Package gcp is the GCP Pub/Sub fanout backend for shimanism's pubsub service.
pubsub/backends/inmem
Package inmem is an in-process pub/sub backend used by the conformance harness as the always-on baseline.
Package inmem is an in-process pub/sub backend used by the conformance harness as the always-on baseline.
pubsub/backends/nats
Package nats is the NATS JetStream backend for shimanism's pubsub service, acting as the K8s peer per PLAN.md Phase 4.
Package nats is the NATS JetStream backend for shimanism's pubsub service, acting as the K8s peer per PLAN.md Phase 4.
pubsub/conformance
Package conformance hosts the backend factories used by the parameterised pubsub conformance tests.
Package conformance hosts the backend factories used by the parameterised pubsub conformance tests.
queue/backends/aws
Package aws is the AWS SQS passthrough backend for shimanism's queue service.
Package aws is the AWS SQS passthrough backend for shimanism's queue service.
queue/backends/azure
Package azure is the Azure Service Bus queue backend for shimanism's queue service.
Package azure is the Azure Service Bus queue backend for shimanism's queue service.
queue/backends/gcp
Package gcp is the GCP Pub/Sub backend for shimanism's queue service.
Package gcp is the GCP Pub/Sub backend for shimanism's queue service.
queue/backends/inmem
Package inmem is an in-process queue backend used by the conformance harness as the always-on baseline.
Package inmem is an in-process queue backend used by the conformance harness as the always-on baseline.
queue/backends/nats
Package nats is the NATS JetStream backend for shimanism's queue service, acting as the K8s peer per PLAN.md Phase 3.
Package nats is the NATS JetStream backend for shimanism's queue service, acting as the K8s peer per PLAN.md Phase 3.
queue/conformance
Package conformance hosts the backend factories used by the parameterised queue conformance tests.
Package conformance hosts the backend factories used by the parameterised queue conformance tests.
rdbms/backends/aws
Package aws is the AWS RDS passthrough backend for shimanism's rdbms service.
Package aws is the AWS RDS passthrough backend for shimanism's rdbms service.
rdbms/backends/azure
Package azure is the Azure DB Admin backend for shimanism's rdbms service.
Package azure is the Azure DB Admin backend for shimanism's rdbms service.
rdbms/backends/cnpg
Package cnpg is the CloudNativePG backend for shimanism's rdbms service, acting as the K8s peer per PLAN.md Phase 5.
Package cnpg is the CloudNativePG backend for shimanism's rdbms service, acting as the K8s peer per PLAN.md Phase 5.
rdbms/backends/gcp
Package gcp is the GCP Cloud SQL Admin backend for shimanism's rdbms service.
Package gcp is the GCP Cloud SQL Admin backend for shimanism's rdbms service.
rdbms/backends/inmem
Package inmem is an in-process rdbms backend used by the conformance harness as the always-on baseline.
Package inmem is an in-process rdbms backend used by the conformance harness as the always-on baseline.
rdbms/conformance
Package conformance hosts the backend factories used by the parameterised rdbms conformance tests.
Package conformance hosts the backend factories used by the parameterised rdbms conformance tests.
registry/backends/aws_ecr
Package aws_ecr implements domain.Registry against real Amazon ECR.
Package aws_ecr implements domain.Registry against real Amazon ECR.
registry/backends/azure_acr
Package azure_acr implements domain.Registry against real Azure Container Registry.
Package azure_acr implements domain.Registry against real Azure Container Registry.
registry/backends/distribution
Package distribution implements domain.Registry against a real CNCF Distribution-compatible registry endpoint.
Package distribution implements domain.Registry against a real CNCF Distribution-compatible registry endpoint.
registry/backends/gcp_artifactregistry
Package gcp_artifactregistry implements domain.Registry against real Google Artifact Registry.
Package gcp_artifactregistry implements domain.Registry against real Google Artifact Registry.
registry/backends/inmem
Package inmem is an in-memory container-registry backend for tests.
Package inmem is an in-memory container-registry backend for tests.
secrets/backends/aws
Package aws is the AWS Secrets Manager passthrough backend.
Package aws is the AWS Secrets Manager passthrough backend.
secrets/backends/azure
Package azure is the Azure Key Vault secrets-surface backend for shimanism's secrets service.
Package azure is the Azure Key Vault secrets-surface backend for shimanism's secrets service.
secrets/backends/gcp
Package gcp is the Google Cloud Secret Manager backend for shimanism's secrets service.
Package gcp is the Google Cloud Secret Manager backend for shimanism's secrets service.
secrets/backends/inmem
Package inmem is an in-process secrets backend used by the conformance harness as the always-on baseline.
Package inmem is an in-process secrets backend used by the conformance harness as the always-on baseline.
secrets/backends/vault
Package vault is the HashiCorp Vault backend for shimanism's secrets service, acting as the K8s peer per PLAN.md Phase 2.
Package vault is the HashiCorp Vault backend for shimanism's secrets service, acting as the K8s peer per PLAN.md Phase 2.
secrets/conformance
Package conformance hosts the backend factories used by the parameterised conformance tests in this directory.
Package conformance hosts the backend factories used by the parameterised conformance tests in this directory.
storage/backends/aws
Package aws is the AWS S3 passthrough backend.
Package aws is the AWS S3 passthrough backend.
storage/backends/azureblob
Package azureblob is the Azure Blob Storage backend for shimanism's neutral storage domain.
Package azureblob is the Azure Blob Storage backend for shimanism's neutral storage domain.
storage/backends/gcs
Package gcs is the Google Cloud Storage backend for shimanism's neutral storage domain.
Package gcs is the Google Cloud Storage backend for shimanism's neutral storage domain.
storage/backends/inmem
Package inmem is a real, in-memory implementation of shimanism's neutral storage domain.
Package inmem is a real, in-memory implementation of shimanism's neutral storage domain.
storage/backends/minio
Package minio is the MinIO backend for shimanism's storage domain.
Package minio is the MinIO backend for shimanism's storage domain.
storage/conformance
Package conformance hosts the backend factories used by the parameterised conformance tests in this directory.
Package conformance hosts the backend factories used by the parameterised conformance tests in this directory.
storage/gen
Package gen contains the generated Go server stubs for the storage service.
Package gen contains the generated Go server stubs for the storage service.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL