outpunch 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f8205e1ea81ec7b911a0180ac666e3d68fbe898a4d7387a04aa4c3b488cf6c73
+  data.tar.gz: 87951c241fc7437be227e386c50dc6286c5fcb0e2fc52107dec249d597bb32a0
+SHA512:
+  metadata.gz: 7abee70786092c2e5125de67dbeb9e529af696d2ac92530d99b35e5428accce9cf75e59cb2fd1a18e6b4b4c42ed8a10e8aae54f1b8ef1c533de162cb319846c3
+  data.tar.gz: '09ac444b6ac28cb1b10c3a49d4707d574f16ec551fc635569bd78a80a3a99e762d50c41006a38e91a155b7b849035d5388331ba647f8769ded2aeb34b77ae704'

data/ext/outpunch/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "outpunch"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+name = "outpunch"
+crate-type = ["cdylib"]
+
+[dependencies]
+outpunch-client = { version = "0.1.1", path = "../../../../crates/outpunch-client" }
+magnus = { version = "0.8" }
+rb-sys = { version = "0.9", features = ["stable-api-compiled-fallback"] }
+tokio = { version = "1.50.0", features = ["full"] }
+
+[build-dependencies]
+rb-sys-build = "0.9"

data/ext/outpunch/extconf.rb

@@ -0,0 +1,4 @@
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("outpunch")

data/ext/outpunch/src/lib.rs

@@ -0,0 +1,163 @@
+use std::sync::Mutex;
+use std::time::Duration;
+
+use magnus::{function, method, prelude::*, wrap, Error, Ruby};
+
+struct ClientConfigInner {
+    server_url: String,
+    secret: String,
+    service: String,
+    forward_to: String,
+    reconnect_delay: f64,
+    request_timeout: f64,
+}
+
+#[wrap(class = "Outpunch::ClientConfig", free_immediately, size)]
+pub struct ClientConfig(Mutex<ClientConfigInner>);
+
+impl ClientConfig {
+    fn new(
+        server_url: String,
+        secret: String,
+        service: String,
+        forward_to: Option<String>,
+        reconnect_delay: Option<f64>,
+        request_timeout: Option<f64>,
+    ) -> Self {
+        Self(Mutex::new(ClientConfigInner {
+            server_url,
+            secret,
+            service,
+            forward_to: forward_to.unwrap_or_else(|| "http://localhost:8080".into()),
+            reconnect_delay: reconnect_delay.unwrap_or(5.0),
+            request_timeout: request_timeout.unwrap_or(25.0),
+        }))
+    }
+
+    fn to_rust(&self) -> outpunch_client::ClientConfig {
+        let inner = self.0.lock().unwrap();
+        outpunch_client::ClientConfig {
+            server_url: inner.server_url.clone(),
+            secret: inner.secret.clone(),
+            service: inner.service.clone(),
+            forward_to: inner.forward_to.clone(),
+            reconnect_delay: Duration::from_secs_f64(inner.reconnect_delay),
+            request_timeout: Duration::from_secs_f64(inner.request_timeout),
+        }
+    }
+
+    fn server_url(&self) -> String {
+        self.0.lock().unwrap().server_url.clone()
+    }
+
+    fn set_server_url(&self, v: String) {
+        self.0.lock().unwrap().server_url = v;
+    }
+
+    fn secret(&self) -> String {
+        self.0.lock().unwrap().secret.clone()
+    }
+
+    fn set_secret(&self, v: String) {
+        self.0.lock().unwrap().secret = v;
+    }
+
+    fn service(&self) -> String {
+        self.0.lock().unwrap().service.clone()
+    }
+
+    fn set_service(&self, v: String) {
+        self.0.lock().unwrap().service = v;
+    }
+
+    fn forward_to(&self) -> String {
+        self.0.lock().unwrap().forward_to.clone()
+    }
+
+    fn set_forward_to(&self, v: String) {
+        self.0.lock().unwrap().forward_to = v;
+    }
+
+    fn reconnect_delay(&self) -> f64 {
+        self.0.lock().unwrap().reconnect_delay
+    }
+
+    fn set_reconnect_delay(&self, v: f64) {
+        self.0.lock().unwrap().reconnect_delay = v;
+    }
+
+    fn request_timeout(&self) -> f64 {
+        self.0.lock().unwrap().request_timeout
+    }
+
+    fn set_request_timeout(&self, v: f64) {
+        self.0.lock().unwrap().request_timeout = v;
+    }
+
+    fn inspect(&self) -> String {
+        let inner = self.0.lock().unwrap();
+        format!(
+            "#<Outpunch::ClientConfig server_url={:?} service={:?} forward_to={:?}>",
+            inner.server_url, inner.service, inner.forward_to
+        )
+    }
+}
+
+fn run(_ruby: &Ruby, config: &ClientConfig) -> Result<(), Error> {
+    let rust_config = config.to_rust();
+    tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+        .block_on(outpunch_client::run(&rust_config));
+    Ok(())
+}
+
+fn run_connection(ruby: &Ruby, config: &ClientConfig) -> Result<(), Error> {
+    let rust_config = config.to_rust();
+    let result = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap()
+        .block_on(outpunch_client::run_connection(&rust_config));
+    result.map_err(|e: Box<dyn std::error::Error + Send + Sync>| {
+        Error::new(ruby.exception_runtime_error(), e.to_string())
+    })
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let module = ruby.define_module("Outpunch")?;
+
+    let config_class = module.define_class("ClientConfig", ruby.class_object())?;
+    config_class.define_singleton_method("new", function!(ClientConfig::new, 6))?;
+    config_class.define_method("server_url", method!(ClientConfig::server_url, 0))?;
+    config_class.define_method("server_url=", method!(ClientConfig::set_server_url, 1))?;
+    config_class.define_method("secret", method!(ClientConfig::secret, 0))?;
+    config_class.define_method("secret=", method!(ClientConfig::set_secret, 1))?;
+    config_class.define_method("service", method!(ClientConfig::service, 0))?;
+    config_class.define_method("service=", method!(ClientConfig::set_service, 1))?;
+    config_class.define_method("forward_to", method!(ClientConfig::forward_to, 0))?;
+    config_class.define_method("forward_to=", method!(ClientConfig::set_forward_to, 1))?;
+    config_class.define_method("reconnect_delay", method!(ClientConfig::reconnect_delay, 0))?;
+    config_class.define_method(
+        "reconnect_delay=",
+        method!(ClientConfig::set_reconnect_delay, 1),
+    )?;
+    config_class.define_method("request_timeout", method!(ClientConfig::request_timeout, 0))?;
+    config_class.define_method(
+        "request_timeout=",
+        method!(ClientConfig::set_request_timeout, 1),
+    )?;
+    config_class.define_method("inspect", method!(ClientConfig::inspect, 0))?;
+    config_class.define_method("to_s", method!(ClientConfig::inspect, 0))?;
+
+    module.define_module_function("run", function!(run, 1))?;
+    module.define_module_function("run_connection", function!(run_connection, 1))?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+#[path = "lib_tests.rs"]
+mod tests;

data/ext/outpunch/src/lib_tests.rs

@@ -0,0 +1,36 @@
+use super::ClientConfig;
+
+#[test]
+fn client_config_defaults() {
+    let config = ClientConfig::new(
+        "wss://example.com/ws".into(),
+        "secret".into(),
+        "my-service".into(),
+        None,
+        None,
+        None,
+    );
+    let rust = config.to_rust();
+    assert_eq!(rust.forward_to, "http://localhost:8080");
+    assert_eq!(rust.reconnect_delay.as_secs_f64(), 5.0);
+    assert_eq!(rust.request_timeout.as_secs_f64(), 25.0);
+}
+
+#[test]
+fn client_config_custom_values() {
+    let config = ClientConfig::new(
+        "wss://example.com/ws".into(),
+        "mysecret".into(),
+        "stormsnap".into(),
+        Some("http://localhost:8081".into()),
+        Some(10.0),
+        Some(30.0),
+    );
+    let rust = config.to_rust();
+    assert_eq!(rust.server_url, "wss://example.com/ws");
+    assert_eq!(rust.secret, "mysecret");
+    assert_eq!(rust.service, "stormsnap");
+    assert_eq!(rust.forward_to, "http://localhost:8081");
+    assert_eq!(rust.reconnect_delay.as_secs_f64(), 10.0);
+    assert_eq!(rust.request_timeout.as_secs_f64(), 30.0);
+}

data/lib/outpunch.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "outpunch/outpunch"

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: outpunch
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- TechyCorp
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description:
+email:
+executables: []
+extensions:
+- ext/outpunch/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/outpunch/Cargo.toml
+- ext/outpunch/extconf.rb
+- ext/outpunch/src/lib.rs
+- ext/outpunch/src/lib_tests.rs
+- lib/outpunch.rb
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Ruby bindings for the outpunch tunnel client
+test_files: []