@rivetkit/engine 1.0.0 → 2.2.1-pr.4600.b74ff3b

package/packages/engine/tests/actors_list_names.rs

@@ -1,353 +0,0 @@
-mod common;
-
-use std::collections::HashSet;
-
-// MARK: Basic
-
-#[test]
-fn list_all_actor_names_in_namespace() {
-	common::run(common::TestOpts::new(1), |ctx| async move {
-		let (namespace, _, _runner) =
-			common::setup_test_namespace_with_runner(ctx.leader_dc()).await;
-
-		// Create actors with different names
-		let names = vec!["actor-alpha", "actor-beta", "actor-gamma"];
-		for name in &names {
-			common::create_actor_with_options(
-				common::CreateActorOptions {
-					namespace: namespace.clone(),
-					name: name.to_string(),
-					..Default::default()
-				},
-				ctx.leader_dc().guard_port(),
-			)
-			.await;
-		}
-
-		// Create multiple actors with same name (should deduplicate)
-		for i in 0..3 {
-			common::create_actor_with_options(
-				common::CreateActorOptions {
-					namespace: namespace.clone(),
-					name: "actor-alpha".to_string(),
-					key: Some(format!("key-{}", i)),
-					..Default::default()
-				},
-				ctx.leader_dc().guard_port(),
-			)
-			.await;
-		}
-
-		// List actor names
-		let response =
-			common::list_actor_names(&namespace, None, None, ctx.leader_dc().guard_port()).await;
-		common::assert_success_response(&response);
-
-		let body: serde_json::Value = response.json().await.expect("Failed to parse response");
-		let returned_names = body["names"].as_array().expect("Expected names array");
-
-		// Should return unique names only
-		assert_eq!(returned_names.len(), 3, "Should return 3 unique names");
-
-		// Verify all names are present
-		let name_set: HashSet<String> = returned_names
-			.iter()
-			.map(|n| n.as_str().unwrap().to_string())
-			.collect();
-		for name in &names {
-			assert!(
-				name_set.contains(*name),
-				"Name {} should be in results",
-				name
-			);
-		}
-	});
-}
-
-#[test]
-fn list_names_with_pagination() {
-	common::run(common::TestOpts::new(1), |ctx| async move {
-		let (namespace, _, _runner) =
-			common::setup_test_namespace_with_runner(ctx.leader_dc()).await;
-
-		// Create actors with many different names
-		for i in 0..10 {
-			common::create_actor_with_options(
-				common::CreateActorOptions {
-					namespace: namespace.clone(),
-					name: format!("actor-{:02}", i),
-					..Default::default()
-				},
-				ctx.leader_dc().guard_port(),
-			)
-			.await;
-		}
-
-		// First page - limit 5
-		let response1 =
-			common::list_actor_names(&namespace, Some(5), None, ctx.leader_dc().guard_port()).await;
-		common::assert_success_response(&response1);
-
-		let body1: serde_json::Value = response1.json().await.expect("Failed to parse response");
-		let names1 = body1["names"].as_array().expect("Expected names array");
-		assert_eq!(names1.len(), 5, "Should return 5 names with limit=5");
-
-		let cursor = body1["cursor"]
-			.as_str()
-			.expect("Should have cursor for pagination");
-
-		// Second page - use cursor
-		let response2 = common::list_actor_names(
-			&namespace,
-			Some(5),
-			Some(cursor),
-			ctx.leader_dc().guard_port(),
-		)
-		.await;
-		common::assert_success_response(&response2);
-
-		let body2: serde_json::Value = response2.json().await.expect("Failed to parse response");
-		let names2 = body2["names"].as_array().expect("Expected names array");
-		assert_eq!(names2.len(), 5, "Should return remaining 5 names");
-
-		// Verify no duplicates between pages
-		let set1: HashSet<String> = names1
-			.iter()
-			.map(|n| n.as_str().unwrap().to_string())
-			.collect();
-		let set2: HashSet<String> = names2
-			.iter()
-			.map(|n| n.as_str().unwrap().to_string())
-			.collect();
-		assert!(
-			set1.is_disjoint(&set2),
-			"Pages should not have duplicate names"
-		);
-	});
-}
-
-#[test]
-fn list_names_returns_empty_array_for_empty_namespace() {
-	common::run(common::TestOpts::new(1), |ctx| async move {
-		let (namespace, _, _runner) =
-			common::setup_test_namespace_with_runner(ctx.leader_dc()).await;
-
-		// List names in empty namespace
-		let response =
-			common::list_actor_names(&namespace, None, None, ctx.leader_dc().guard_port()).await;
-		common::assert_success_response(&response);
-
-		let body: serde_json::Value = response.json().await.expect("Failed to parse response");
-		let names = body["names"].as_array().expect("Expected names array");
-		assert_eq!(
-			names.len(),
-			0,
-			"Should return empty array for empty namespace"
-		);
-	});
-}
-
-// MARK: Error Cases
-
-#[test]
-fn list_names_with_non_existent_namespace() {
-	common::run(common::TestOpts::new(1), |ctx| async move {
-		// Try to list names with non-existent namespace
-		let response = common::list_actor_names(
-			"non-existent-namespace",
-			None,
-			None,
-			ctx.leader_dc().guard_port(),
-		)
-		.await;
-
-		// Should fail with namespace not found
-		assert!(
-			!response.status().is_success(),
-			"Should fail with non-existent namespace"
-		);
-		common::assert_error_response(response, "namespace_not_found").await;
-	});
-}
-
-#[test]
-fn list_names_with_invalid_cursor_format() {
-	common::run(common::TestOpts::new(1), |ctx| async move {
-		let (namespace, _, _runner) =
-			common::setup_test_namespace_with_runner(ctx.leader_dc()).await;
-
-		// Try with invalid cursor
-		let response = common::list_actor_names(
-			&namespace,
-			None,
-			Some("invalid-cursor-format"),
-			ctx.leader_dc().guard_port(),
-		)
-		.await;
-
-		// Should fail with invalid cursor
-		assert!(
-			!response.status().is_success(),
-			"Should fail with invalid cursor"
-		);
-	});
-}
-
-// MARK: Cross-Datacenter Tests
-
-#[test]
-fn list_names_fanout_to_all_datacenters() {
-	common::run(common::TestOpts::new(2), |ctx| async move {
-		let (namespace, _, _runner) =
-			common::setup_test_namespace_with_runner(ctx.leader_dc()).await;
-
-		// Create actors with different names in different DCs
-		common::create_actor_with_options(
-			common::CreateActorOptions {
-				namespace: namespace.clone(),
-				name: "dc1-actor".to_string(),
-				..Default::default()
-			},
-			ctx.leader_dc().guard_port(),
-		)
-		.await;
-
-		common::create_actor_with_options(
-			common::CreateActorOptions {
-				namespace: namespace.clone(),
-				name: "dc2-actor".to_string(),
-				datacenter: Some("dc-2".to_string()),
-				..Default::default()
-			},
-			ctx.get_dc(2).guard_port(),
-		)
-		.await;
-
-		// Wait for propagation
-		common::wait_for_eventual_consistency().await;
-
-		// List names from DC 1 - should fanout to all DCs
-		let response =
-			common::list_actor_names(&namespace, None, None, ctx.leader_dc().guard_port()).await;
-		common::assert_success_response(&response);
-
-		let body: serde_json::Value = response.json().await.expect("Failed to parse response");
-		let names = body["names"].as_array().expect("Expected names array");
-
-		// Should return names from both DCs
-		let name_set: HashSet<String> = names
-			.iter()
-			.map(|n| n.as_str().unwrap().to_string())
-			.collect();
-		assert!(
-			name_set.contains("dc1-actor"),
-			"Should contain DC1 actor name"
-		);
-		assert!(
-			name_set.contains("dc2-actor"),
-			"Should contain DC2 actor name"
-		);
-	});
-}
-
-#[test]
-fn list_names_deduplication_across_datacenters() {
-	common::run(common::TestOpts::new(2), |ctx| async move {
-		let (namespace, _, _runner) =
-			common::setup_test_namespace_with_runner(ctx.leader_dc()).await;
-
-		// Create actors with same name in different DCs
-		let shared_name = "shared-name-actor";
-
-		common::create_actor_with_options(
-			common::CreateActorOptions {
-				namespace: namespace.clone(),
-				name: shared_name.to_string(),
-				key: Some("dc1-key".to_string()),
-				..Default::default()
-			},
-			ctx.leader_dc().guard_port(),
-		)
-		.await;
-
-		common::create_actor_with_options(
-			common::CreateActorOptions {
-				namespace: namespace.clone(),
-				name: shared_name.to_string(),
-				key: Some("dc2-key".to_string()),
-				datacenter: Some("dc-2".to_string()),
-				..Default::default()
-			},
-			ctx.get_dc(2).guard_port(),
-		)
-		.await;
-
-		// Wait for propagation
-		common::wait_for_eventual_consistency().await;
-
-		// List names - should deduplicate
-		let response =
-			common::list_actor_names(&namespace, None, None, ctx.leader_dc().guard_port()).await;
-		common::assert_success_response(&response);
-
-		let body: serde_json::Value = response.json().await.expect("Failed to parse response");
-		let names = body["names"].as_array().expect("Expected names array");
-
-		// Should return only one instance of the name
-		let name_count = names
-			.iter()
-			.filter(|n| n.as_str().unwrap() == shared_name)
-			.count();
-		assert_eq!(name_count, 1, "Should deduplicate names across datacenters");
-	});
-}
-
-#[test]
-fn list_names_alphabetical_sorting() {
-	common::run(common::TestOpts::new(1), |ctx| async move {
-		let (namespace, _, _runner) =
-			common::setup_test_namespace_with_runner(ctx.leader_dc()).await;
-
-		// Create actors with names that need sorting
-		let unsorted_names = vec!["zebra-actor", "alpha-actor", "beta-actor", "gamma-actor"];
-		for name in &unsorted_names {
-			common::create_actor_with_options(
-				common::CreateActorOptions {
-					namespace: namespace.clone(),
-					name: name.to_string(),
-					..Default::default()
-				},
-				ctx.leader_dc().guard_port(),
-			)
-			.await;
-		}
-
-		// List names
-		let response =
-			common::list_actor_names(&namespace, None, None, ctx.leader_dc().guard_port()).await;
-		common::assert_success_response(&response);
-
-		let body: serde_json::Value = response.json().await.expect("Failed to parse response");
-		let names = body["names"].as_array().expect("Expected names array");
-
-		// Convert to strings for comparison
-		let returned_names: Vec<String> = names
-			.iter()
-			.map(|n| n.as_str().unwrap().to_string())
-			.collect();
-
-		// Verify alphabetical order
-		let mut sorted_names = returned_names.clone();
-		sorted_names.sort();
-		assert_eq!(
-			returned_names, sorted_names,
-			"Names should be returned in alphabetical order"
-		);
-
-		// Verify expected order
-		assert_eq!(returned_names[0], "alpha-actor");
-		assert_eq!(returned_names[1], "beta-actor");
-		assert_eq!(returned_names[2], "gamma-actor");
-		assert_eq!(returned_names[3], "zebra-actor");
-	});
-}

package/packages/engine/tests/common/ns.rs

@@ -1,36 +0,0 @@
-use std::str::FromStr;
-
-pub async fn create_namespace(name: &str, guard_port: u16) -> rivet_util::Id {
-	tracing::info!(?name, ?guard_port, "creating test namespace");
-
-	let client = reqwest::Client::new();
-	let response = client
-		.post(format!("http://127.0.0.1:{}/namespaces", guard_port))
-		.json(&serde_json::json!({
-			"name": name,
-			"display_name": "Test Namespace",
-		}))
-		.send()
-		.await
-		.expect("Failed to send namespace creation request");
-
-	if !response.status().is_success() {
-		let text = response.text().await.expect("Failed to read response text");
-		panic!("Failed to create namespace: {}", text);
-	}
-
-	let body: serde_json::Value = response
-		.json()
-		.await
-		.expect("Failed to parse JSON response");
-	let namespace_id = body["namespace"]["namespace_id"]
-		.as_str()
-		.expect("Missing namespace_id in response");
-
-	let namespace_id =
-		rivet_util::Id::from_str(namespace_id).expect("Failed to parse namespace ID");
-
-	tracing::info!(?namespace_id, ?name, "namespace created");
-
-	namespace_id
-}

package/packages/engine/tests/common/runner.rs

@@ -1,134 +0,0 @@
-use std::{path::Path, time::Duration};
-
-use rivet_util::Id;
-use tokio::process::{Child, Command};
-
-pub struct TestRunner {
-	pub runner_id: Id,
-	internal_port: u16,
-	pub port: u16,
-	handle: Child,
-}
-
-impl TestRunner {
-	pub async fn new(
-		port: u16,
-		namespace_name: &str,
-		key: &str,
-		version: u32,
-		total_slots: u32,
-	) -> Self {
-		let internal_server_port = portpicker::pick_unused_port().expect("runner http server port");
-		let http_server_port = portpicker::pick_unused_port().expect("runner http server port");
-
-		tracing::info!(?internal_server_port, ?http_server_port, "starting runner");
-
-		let manifest_dir = env!("CARGO_MANIFEST_DIR");
-		let runner_script_path =
-			Path::new(manifest_dir).join("../../../sdks/typescript/test-runner/dist/index.js");
-
-		if !runner_script_path.exists() {
-			panic!(
-				"Runner script not found at '{}'. Build it first with `pnpm install && pnpm build -F @rivetkit/engine-test-runner`.",
-				runner_script_path.display(),
-			);
-		}
-
-		let handle = Command::new("node")
-			.arg(runner_script_path)
-			.env("INTERNAL_SERVER_PORT", internal_server_port.to_string())
-			.env("RIVET_NAMESPACE", namespace_name)
-			.env("RIVET_RUNNER_KEY", key.to_string())
-			.env("RIVET_RUNNER_VERSION", version.to_string())
-			.env("RIVET_RUNNER_TOTAL_SLOTS", total_slots.to_string())
-			.env("RIVET_ENDPOINT", format!("http://127.0.0.1:{port}"))
-			.kill_on_drop(true)
-			.spawn()
-			.expect("Failed to execute runner js file, node not installed");
-
-		let runner_id = Self::wait_ready(internal_server_port).await;
-
-		TestRunner {
-			runner_id,
-			internal_port: internal_server_port,
-			port: http_server_port,
-			handle,
-		}
-	}
-
-	async fn wait_ready(port: u16) -> Id {
-		let client = reqwest::Client::new();
-		let mut attempts = 0;
-
-		loop {
-			let res = client
-				.get(format!("http://127.0.0.1:{port}/wait-ready"))
-				.send()
-				.await;
-
-			let response = match res {
-				Ok(x) => x,
-				Err(err) => {
-					if attempts < 10 {
-						attempts += 1;
-						tokio::time::sleep(Duration::from_millis(150)).await;
-						continue;
-					} else {
-						Err(err).expect("Failed to send wait ready request to runner")
-					}
-				}
-			};
-
-			if !response.status().is_success() {
-				if attempts < 10 {
-					attempts += 1;
-					tokio::time::sleep(Duration::from_millis(150)).await;
-					continue;
-				}
-
-				let text = response.text().await.expect("Failed to read response text");
-				panic!("Failed to wait ready for runner: {text}");
-			}
-
-			return response
-				.json()
-				.await
-				.expect("Failed to parse JSON response");
-		}
-	}
-
-	pub async fn has_actor(&self, actor_id: &str) -> bool {
-		let client = reqwest::Client::new();
-		let response = client
-			.get(format!("http://127.0.0.1:{}/has-actor", self.internal_port))
-			.query(&[("actor", actor_id)])
-			.send()
-			.await
-			.expect("Failed to send request has-actor to runner");
-
-		if response.status() == reqwest::StatusCode::NOT_FOUND {
-			return false;
-		}
-
-		if response.status().is_success() {
-			return true;
-		}
-
-		let text = response.text().await.expect("Failed to fetch has-actor");
-		panic!("Failed to fetch has-actor: {text}");
-	}
-
-	pub async fn shutdown(&self) {
-		let client = reqwest::Client::new();
-		let response = client
-			.get(format!("http://127.0.0.1:{}/shutdown", self.internal_port))
-			.send()
-			.await
-			.expect("Failed to send shutdown request to runner");
-
-		if !response.status().is_success() {
-			let text = response.text().await.expect("Failed to read response text");
-			panic!("Failed to shutdown runner: {text}");
-		}
-	}
-}

package/packages/engine/tests/runners_dupe_key.rs

@@ -1,27 +0,0 @@
-mod common;
-
-#[test]
-fn runner_dupe_key() {
-	common::run(common::TestOpts::new(1), |ctx| async move {
-		let (namespace, _) = common::setup_test_namespace(ctx.leader_dc().guard_port()).await;
-
-		let runner1 = common::setup_runner(ctx.leader_dc(), &namespace, "key-1", 1, 1).await;
-		let runner2 = common::setup_runner(ctx.leader_dc(), &namespace, "key-1", 1, 1).await;
-
-		let res = ctx
-			.leader_dc()
-			.workflow_ctx
-			.op(pegboard::ops::runner::get::Input {
-				runner_ids: vec![runner1.runner_id, runner2.runner_id],
-			})
-			.await
-			.unwrap();
-		let mut runners = res.runners.into_iter();
-
-		let runner1 = runners.next().unwrap();
-		let runner2 = runners.next().unwrap();
-
-		assert!(runner1.drain_ts.is_some(), "runner1 not draining");
-		assert!(runner2.drain_ts.is_none(), "runner2 is draining");
-	});
-}

package/packages/engine/tests/runners_version.rs

@@ -1,50 +0,0 @@
-mod common;
-
-#[test]
-fn runner_version_upgrade() {
-	common::run(common::TestOpts::new(1), |ctx| async move {
-		let (namespace, _) = common::setup_test_namespace(ctx.leader_dc().guard_port()).await;
-		let _runner1 = common::setup_runner(ctx.leader_dc(), &namespace, "key-1", 1, 1).await;
-		let runner2 = common::setup_runner(ctx.leader_dc(), &namespace, "key-2", 2, 2).await;
-
-		// Create actor to fill a single slot. This forces the second allocation to either be in the other
-		// runner, or in the same runner IF runner versions are implemented correctly.
-		let actor_id1 = common::create_actor_with_options(
-			common::CreateActorOptions {
-				namespace: namespace.clone(),
-				name: "actor1".to_string(),
-				key: None,
-				datacenter: None,
-				..Default::default()
-			},
-			ctx.leader_dc().guard_port(),
-		)
-		.await;
-
-		assert!(!actor_id1.is_empty(), "Actor ID should not be empty");
-
-		common::assert_actor_exists(&actor_id1, &namespace, ctx.leader_dc().guard_port()).await;
-
-		common::assert_actor_in_runner(ctx.leader_dc(), &actor_id1, &runner2.runner_id.to_string())
-			.await;
-
-		let actor_id2 = common::create_actor_with_options(
-			common::CreateActorOptions {
-				namespace: namespace.clone(),
-				name: "actor2".to_string(),
-				key: None,
-				datacenter: None,
-				..Default::default()
-			},
-			ctx.leader_dc().guard_port(),
-		)
-		.await;
-
-		assert!(!actor_id2.is_empty(), "Actor ID should not be empty");
-
-		common::assert_actor_exists(&actor_id2, &namespace, ctx.leader_dc().guard_port()).await;
-
-		common::assert_actor_in_runner(ctx.leader_dc(), &actor_id2, &runner2.runner_id.to_string())
-			.await;
-	});
-}

package/packages/env/build.rs

@@ -1,8 +0,0 @@
-use anyhow::Result;
-use vergen::Emitter;
-
-fn main() -> Result<()> {
-	Emitter::default().emit()?;
-
-	Ok(())
-}

package/packages/epoxy/spec/KEYS.md

@@ -1,33 +0,0 @@
-# Keys
-
-## Key Hierarchy
-
-```
-/rivet/epoxy/
-	replica/{replica_id}/
-		config = {Config}                            # Replica configuration with epoch and peer info
-		instance_number = {u32}                      # Track instance number for next instance
-		current_ballot = {Ballot}                    # Current ballot number for this replica
-		instance_ballot/{replica}/{slot} = {Ballot}  # Highest ballot seen for each instance
-		log/{replica}/{slot}/entry = {LogEntry}
-		key_instance/{key}/{replica}/{slot} = ()     # Used for checking interference
-		key_value/{key}/
-			committed_value = Vec<u8>                # Value written on commit
-			optimistic_cached_value = Vec<u8>        # Value read from remote datacenters in kv::get_optimistic
-```
-
-### Design Notes
-
-- `key_instances/{key}` is stored separately from `keys/{key}` because we need to efficiently be able to do a range scan over key_instances in order to find interference, so we need to minimize keys in that subspace
-- `instance_number` should be replaced with `version_stamp` to reduce contention
-
-### Contention
-
-- `lead_consensus`
-	- `instance_number`
-	- `current_ballot`
-- `find_interference` & `update_log`
-	- `key_instances/{key}/({replica,slot})`
-- `validate_ballot_for_instance`
-	- `instance_ballot/{replica}/{slot}`
-