// STRYKE-DEMO — LIVE DEMOS FOR EVERY STRYKE-* PACKAGE

The 14 demos

Color legend: green = no service required · cyan = local docker-compose can host it · yellow = real cloud creds required.

Install

# clone + bootstrap with stryke's package manager
git clone https://github.com/MenkeTechnologies/stryke-demo
cd stryke-demo
s install            # pulls all 14 stryke-* packages from GitHub
make install         # same thing, via the Makefile

s install resolves the 14 git deps declared in stryke.toml, builds each package's Rust cdylib into the global stryke store, and locks the resolved graph into stryke.lock. There is no per-demo install step — each demo script loads its package with a single use directive (e.g. use Arrow) and the connector is already in the store. The stryke binary is invoked as s throughout this repo (the Makefile, stryke.toml scripts, and every demo's #!/usr/bin/env stryke shebang).

Spin up all live services

# bring up MySQL, Postgres, Kafka, Redis, MongoDB, LocalStack, k3s
make up               # wraps `docker compose up -d`

# verify everything is healthy
docker compose ps

# tear down + clear volumes
make down             # wraps `docker compose down -v`

docker-compose.yml ships exactly seven service containers — mysql, postgres, redis, mongo, kafka (KRaft, single-node), localstack (S3 + DynamoDB + SQS + Lambda + STS), and k3s (single-node Kubernetes for the stryke-k8s demo). The Arrow, Parquet, DuckDB, and Spark demos run embedded — no docker required. The gRPC demo expects an externally-running reflection-enabled gRPC server (not part of docker-compose.yml), and the GCP demo needs real Google Cloud credentials (no local emulator).

Run a single demo

Every demo has a one-word make target that sets the connection env vars for you, or you can invoke the .stk file directly with s:

# in-process / embedded — no service needed
make arrow            # s demos/01_arrow.stk
make duckdb           # s demos/10_duckdb.stk
make spark            # s demos/04_spark.stk
make parquet          # s demos/09_parquet.stk

# service-backed — `make up` (or your own service) must be reachable
make mysql            # MYSQL_URI=mysql://root:root@127.0.0.1:3306/test
make postgres         # POSTGRES_URI=postgres://postgres:postgres@127.0.0.1:5432/postgres
make redis            # REDIS_URL=redis://localhost:6379
make mongo            # MONGODB_URI=mongodb://localhost:27017
make kafka            # KAFKA_BROKERS=localhost:9092
make aws              # AWS_ENDPOINT_URL=http://localhost:4566 (LocalStack)
make k8s              # uses $KUBECONFIG / k3s kubeconfig
make docker           # uses $DOCKER_HOST or /var/run/docker.sock

# need explicit positional args (no make target wires them):
s demos/06_gcp.stk gs://my-bucket projects/p/subscriptions/sub projects/p/topics/t
s demos/08_grpc.stk localhost:50051

Each demo prints what it's doing as it goes — nothing magic, nothing hidden. Read the .stk file to see exactly which package functions are being exercised; the demos are written to call every public verb of their connector, with the function name printed alongside each line of output (e.g. Arrow::read_columnar limit=3 cols: ...).

Run everything available

# probe each service, skip demos whose dependency is unreachable
make all

# or the raw stryke entrypoint that does the probing
s demos/run_all.stk

run_all.stk calls each connector's ::ping() (and AWS::sts_caller_identity() for AWS) and runs only the demos whose backing service answers. The four in-process demos (arrow, parquet, duckdb, spark) always run. Demos whose service is unreachable print ── NN name: SKIP (service not reachable) and the runner moves on. The GCP and gRPC demos require explicit positional arguments, so run_all.stk prints a one-line reminder for each rather than invoking them.

Environment variables

Connection details are read from the environment. The make targets set sensible localhost defaults (matching docker-compose.yml); override them to point at your own services.

Three demos also read optional opt-in flags that enable extra (slower or destructive) operations: STRYKE_DEMO_LAMBDA (aws — exercise lambda_invoke), STRYKE_DEMO_DOCKER_BUILD / STRYKE_DEMO_DOCKER_PUSH (docker — build/push an image), and STRYKE_DEMO_SPARK_SCRIPT (spark — submit a script via Spark::submit). Left unset, those branches are skipped.

Connector API reference

Each demo is written to call every public verb of its connector. The lists below are the exact functions exercised by each .stk file — read the demo source to see argument shapes and option keys (named args like limit =>, bind =>, columns =>, compression =>).

Cross-connector integration tests

Beyond the single-connector demos, the t/ directory holds standalone integration tests that wire connectors together — e.g. write with Arrow, query the same file with DuckDB, and reconcile the row counts against the Parquet footer. They cover Arrow compute pipelines, Parquet footer diagnostics and compression codecs, Arrow↔DuckDB type round-trips, DuckDB CTAS/COPY TO and read_parquet/read_csv/read_json direct reads, summarize/describe vs Arrow stats, and Polars CSV round-trips and group-by vs DuckDB. Run one directly:

s t/integration_arrow_duckdb.stk
s t/integration_duckdb_summarize_describe_vs_arrow_stats.stk

Layout

stryke-demo/
├── demos/
│   ├── 01_arrow.stk        # arrow / csv / parquet / feather / json / ipc I/O
│   ├── 02_mysql.stk        # CREATE / INSERT / SELECT + bind + insert_many
│   ├── 03_postgres.stk     # same shape as mysql
│   ├── 04_spark.stk        # SparkSQL via embedded DataFusion session
│   ├── 05_aws.stk          # S3 + DynamoDB + STS (+ optional Lambda) via LocalStack
│   ├── 06_gcp.stk          # GCS put/get/list + Pub/Sub publish/pull
│   ├── 07_kafka.stk        # create-topic + produce + consume + admin + delete
│   ├── 08_grpc.stk         # reflection-driven list + describe + call
│   ├── 09_parquet.stk      # inspect + schema + stats + head/tail + recompress
│   ├── 10_duckdb.stk       # in-mem + bind + import/export + file db
│   ├── 11_redis.stk        # strings + lists + hashes + sets + sorted sets
│   ├── 12_mongo.stk        # CRUD + aggregate + index admin
│   ├── 13_k8s.stk          # discovery + create/apply + scale + logs + cleanup
│   ├── 14_docker.stk       # pull + run + inspect + exec + logs + networks/volumes
│   └── run_all.stk         # ping each service + run reachable demos
├── t/                      # cross-connector integration tests
├── docker-compose.yml      # mysql / postgres / redis / mongo / kafka / localstack / k3s
├── Makefile                # `make <name>`, `up`, `down`, `all`, `install`, `clean`
├── stryke.toml             # package manifest (declares the 14 deps)
└── docs/                   # this site (GitHub Pages)

Updating dep pins

stryke.toml pins each stryke-* package to branch = "main". When the packages start cutting vX.Y.Z tags, swap branch = "main" to tag = "vX.Y.Z" for reproducible installs, then re-run s install to refresh stryke.lock:

s install         # re-resolve deps and rewrite stryke.lock
make clean        # drop target/, tmp/, stryke.lock for a clean re-resolve

Sibling packages

Part of the stryke package family. Browse the others via the MenkeTechnologiesMeta umbrella repo:

• stryke-arrow — Apache Arrow / Parquet / Feather
• stryke-aws — S3, DynamoDB, SQS, Lambda, STS
• stryke-azure — Blob, Queues, Cosmos DB, Key Vault, Entra
• stryke-clickhouse — ClickHouse
• stryke-docker — Docker daemon API
• stryke-duckdb — embedded DuckDB SQL engine
• stryke-email — email + campaign client
• stryke-fleet — parallel expect/PTY automation
• stryke-gcp — Cloud Storage, Pub/Sub, Secret Manager, BigQuery, Firestore
• stryke-grpc — reflection-based gRPC client
• stryke-gui — mouse / keyboard / screen / clipboard automation
• stryke-k8s — Kubernetes
• stryke-kafka — Apache Kafka
• stryke-mcpd — MCP servers without a runtime
• stryke-mongo — MongoDB
• stryke-mssql — Microsoft SQL Server
• stryke-mysql — MySQL / MariaDB
• stryke-neo4j — Neo4j graph (Bolt)
• stryke-office — Office docs / PDF / images
• stryke-parquet — Parquet file inspector
• stryke-polars — Polars + ndarray + linalg + FFT
• stryke-postgres — PostgreSQL
• stryke-redis — Redis / Valkey
• stryke-scrape — web scraping / crawling
• stryke-scylla — ScyllaDB / Cassandra
• stryke-search — Elasticsearch / OpenSearch
• stryke-selenium — browser automation (WebDriver)
• stryke-spark — Spark Connect (no JVM)
• stryke-utils — pure-stryke utility belt
• stryke-zmq — ZeroMQ messaging