exogress 0.0.1.pre.alpha.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 42d872bfac64e0884243c5d88749bb49f8b41e252fcafbf2728b477ccb7e9008
+  data.tar.gz: acc49bfacac41bfa1846708b2a1beeb59cf21ea2ef460c9be0c9a29d580bed60
+SHA512:
+  metadata.gz: 2c475a896a86f6d55086deb8bb7ef09510b83373a87a7400b500265c5e95738d17b2e6b43d9bcd44bf82d037a9bceeb3011e2ac00735b9dcb281703fadc0451e
+  data.tar.gz: d8d0eacd302e4ac60c828a748c63cafa037c92f6695e4eb45a20a61dc1dd7f8fa42923c688aed16a69be53a1d0629e807f8e078b8500925624928e1f73ed711f

data/.github/workflows/main.yml

@@ -0,0 +1,29 @@
+name: Ruby
+
+on: [push,pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 3.0.1
+
+    - name: Build and publish
+      run: |
+        gem install bundler -v 2.2.15
+        bundle install
+        bundle exec rake build
+
+    - name: Publish to RubyGems
+      run: |
+        mkdir -p $HOME/.gem
+        touch $HOME/.gem/credentials
+        chmod 0600 $HOME/.gem/credentials
+        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+        gem push pkg/*.gem
+      env:
+        GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_API_KEY}}"

data/.gitignore

@@ -0,0 +1,14 @@
+/target
+Cargo.lock
+
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# Editor-based HTTP Client requests
+/httpRequests/

data/.idea/exogress-ruby.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="CPP_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

data/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/exogress-ruby.iml" filepath="$PROJECT_DIR$/.idea/exogress-ruby.iml" />
+    </modules>
+  </component>
+</project>

data/.idea/vcs.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/exogress" vcs="Git" />
+  </component>
+</project>

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "exogress-ruby"
+version = "0.0.1-alpha.1"
+edition = "2018"
+
+[dependencies]
+rutie = "0.8.2"
+exogress-common = { git = "https://github.com/exogress/exogress.git", branch = "master", version = "0.2.0", features = ["client-core", "tunnel", "config-core", "entities", "common-utils"], default-features = false }
+futures = "0.3.5"
+trust-dns-resolver = "0.20.0"
+hashbrown = "0.11.2"
+tokio = { version = "1.0", features = ["macros", "rt-multi-thread", "rt", "parking_lot"] }
+anyhow = "1.0.41"
+#log = "0.4.14"
+parking_lot = "0.11.1"
+lazy_static = "1.4.0"
+
+[lib]
+name = "rutie_exogress"
+crate-type = ["cdylib"]
+

data/Exofile.yml

@@ -0,0 +1,14 @@
+---
+version: 1.1.0
+revision: 1
+name: default
+mount-points:
+  default:
+    handlers:
+      proxy:
+        kind: proxy
+        priority: 50
+        upstream: backend
+upstreams:
+  backend:
+    port: 4001

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in exogress.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+gem 'rutie', '~> 0.0.4'

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    exogress (0.0.1.pre.alpha.1)
+      rutie (~> 0.0.4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.4.4)
+    rake (13.0.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    rutie (0.0.4)
+
+PLATFORMS
+  x86_64-darwin-20
+  x86_64-linux
+
+DEPENDENCIES
+  bundler
+  exogress!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  rutie (~> 0.0.4)
+
+BUNDLED WITH
+   2.2.15

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Gleb Pomykalov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# Exogress
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/exogress`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'exogress'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install exogress
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/exogress.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rbconfig"
+
+task default: :build_lib
+
+# Mac OS with rbenv users keep leaving behind build artifacts from
+#   when they tried to build against a statically linked Ruby and then
+#   try against a dynamically linked one causing errors in the build result.
+desc 'Preventative work'
+task :tidy_up do
+  sh 'cargo clean'
+end
+
+desc 'Build Rust extension'
+task :build_lib do
+  case RbConfig::CONFIG['host_os']
+  when /darwin|mac os/
+    sh 'cargo rustc --release -- -C link-args=-Wl,-undefined,dynamic_lookup'
+  else
+    sh 'cargo build --release'
+  end
+end
+
+desc 'bundle install'
+task :bundle_install do
+  sh 'bundle install'
+end
+
+begin
+    require "rspec/core/rake_task"
+    RSpec::Core::RakeTask.new(spec: [:bundle_install, :build_lib]) do |t|
+    end
+rescue LoadError
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "exogress"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/example/example.rb

@@ -0,0 +1,30 @@
+require_relative "../lib/exogress"
+require 'logger'
+
+logger = Logger.new(STDOUT)
+logger.level = Logger::WARN
+
+Instance.set_logger(logger)
+logger.info("Starting exogress.!")
+instance = Instance.new({
+    access_key_id: "01F68JEA8XW0MM1XGGR47F7KSD",
+    secret_access_key: "a83Xj28xao6UkHRasZUhVVrrhc26w8RMJsyV7kkgn7jU",
+    account: "glebpom",
+    project: "location-tester",
+    labels: {
+        "label1": "val1",
+    }
+})
+
+Thread.new do
+    print("Spawn instance!")
+    instance.spawn()
+    print("instance stopped")
+end
+
+sleep(5)
+print("reload")
+instance.reload
+sleep(5)
+print("stop")
+instance.stop

data/exogress.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "lib/exogress/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "exogress"
+  spec.version       = Exogress::VERSION
+  spec.authors       = ["Exogress Team"]
+  spec.email         = ["team@exogress.com"]
+
+  spec.summary       = "Exogress client for Ruby"
+  spec.description   = "Exogress is an edge network built for your cloud"
+  spec.homepage      = "https://exogess.com"
+  spec.license       = "Apache 2.0"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+#   spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/exogress/exogress-ruby"
+#   spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions = %w(Rakefile)
+
+  spec.add_dependency 'rutie', '~> 0.0.4'
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+end

data/lib/exogress.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "exogress/version"
+require 'rutie'
+
+class ExogressError < StandardError
+end
+
+class EntityError < StandardError
+end
+
+module Exogress
+  Rutie.new(:rutie_exogress).init 'Init_rutie_exogress', __dir__
+end

data/lib/exogress/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Exogress
+  VERSION = "0.0.1-alpha.1"
+end

data/src/instance.rs

@@ -0,0 +1,308 @@
+use lazy_static::lazy_static;
+
+use rutie::{Class, Object, RString, VM, Hash, Symbol, AnyException, Boolean, NilClass};
+use exogress_common::entities::{AccessKeyId, ProjectName, AccountName, LabelName, LabelValue};
+use rutie::Exception;
+use std::str::FromStr;
+use hashbrown::HashMap;
+use rutie::types::ValueType;
+use futures::channel::mpsc::{self, UnboundedSender, UnboundedReceiver};
+use futures::channel::oneshot;
+use exogress_common::entities::SmolStr;
+use exogress_common::client_core::Client;
+use tokio::runtime::Runtime;
+use trust_dns_resolver::TokioAsyncResolver;
+use trust_dns_resolver::TokioHandle;
+use rutie::Thread;
+use std::sync::Arc;
+use rutie::AnyObject;
+
+const CRATE_VERSION: &'static str = env!("CARGO_PKG_VERSION");
+
+pub struct RustInstance {
+    client: parking_lot::Mutex<Option<exogress_common::client_core::Client>>,
+    reload_config_tx: parking_lot::Mutex<UnboundedSender<()>>,
+    reload_config_rx: Arc<parking_lot::Mutex<Option<UnboundedReceiver<()>>>>,
+    stop_tx: parking_lot::Mutex<Option<oneshot::Sender<()>>>,
+    stop_rx: Arc<parking_lot::Mutex<Option<oneshot::Receiver<()>>>>,
+}
+
+wrappable_struct!(RustInstance, RustInstanceWrapper, INSTANCE_WRAPPER);
+
+fn get_string_entity<T>(k: &str, args: &Hash) -> T
+    where
+        T: FromStr,
+        <T as FromStr>::Err: std::fmt::Display,
+{
+    args
+        .at(&Symbol::new(k))
+        .try_convert_to::<RString>()
+        .map_err(|e| VM::raise_ex(e))
+        .unwrap()
+        .to_string()
+        .parse::<T>()
+        .map_err(|e| {
+            let exception = AnyException::new("EntityError", Some(e.to_string().as_str()));
+            VM::raise_ex(exception);
+        })
+        .unwrap()
+}
+
+fn get_string_entity_optional<T>(k: &str, args: &Hash) -> Option<T>
+    where
+        T: FromStr,
+        <T as FromStr>::Err: std::fmt::Display,
+{
+    let val = args
+        .at(&Symbol::new(k));
+    if val.is_nil() {
+        return None;
+    } else {
+        Some(val
+            .try_convert_to::<RString>()
+            .map_err(|e| VM::raise_ex(e))
+            .unwrap()
+            .to_string()
+            .parse::<T>()
+            .map_err(|e| {
+                let exception = AnyException::new("EntityError", Some(e.to_string().as_str()));
+                VM::raise_ex(exception);
+            })
+            .unwrap())
+    }
+}
+
+fn get_bool_entity(k: &str, default: bool, args: &Hash) -> bool
+{
+    let val = args
+        .at(&Symbol::new(k));
+    if val.is_nil() {
+        return default;
+    } else {
+        val
+            .try_convert_to::<Boolean>()
+            .map_err(|e| VM::raise_ex(e))
+            .unwrap()
+            .to_bool()
+    }
+}
+
+class!(Instance);
+
+methods!(
+    Instance,
+    itself,
+
+    fn new(args: Hash) -> Class {
+        let args = args.map_err(|e| VM::raise_ex(e)).unwrap();
+        let account: AccountName = get_string_entity("account", &args);
+        let project: ProjectName = get_string_entity("project", &args);
+        let access_key_id: AccessKeyId = get_string_entity("access_key_id", &args);
+        let config_path: Option<String> = get_string_entity_optional("config_path", &args);
+        let watch_config = get_bool_entity("watch_config", true, &args);
+
+        let mut labels = hashbrown::HashMap::new();
+        let labels_ruby = args.at(&Symbol::new("labels"));
+        if labels_ruby.ty() == ValueType::Hash {
+            let labels_ruby = labels_ruby
+                .try_convert_to::<Hash>()
+                .map_err(|e| VM::raise_ex(e))
+                .unwrap();
+
+            labels_ruby.each(|k,v| {
+                let as_symbol = k
+                        .try_convert_to::<Symbol>()
+                        .map(|symbol| {
+                            symbol
+                                .to_string()
+                        });
+
+                let k = as_symbol.unwrap_or_else(|_| {
+                    k
+                        .try_convert_to::<RString>()
+                        .map_err(|e| VM::raise_ex(e))
+                        .unwrap()
+                        .to_string()
+                });
+
+                labels.insert(
+                    k.parse::<LabelName>()
+                        .map_err(|e| {
+                            let exception = AnyException::new("EntityError", Some(e.to_string().as_str()));
+                            VM::raise_ex(exception);
+                        })
+                        .unwrap(),
+                    v
+                        .try_convert_to::<RString>()
+                        .map_err(|e| VM::raise_ex(e))
+                        .unwrap()
+                        .to_string()
+                        .parse::<LabelValue>()
+                        .map_err(|e| {
+                            let exception = AnyException::new("EntityError", Some("bad label value"));
+                            VM::raise_ex(exception);
+                        })
+                        .unwrap()
+                );
+            });
+        }
+        let secret_access_key = args
+            .at(&Symbol::new("secret_access_key"))
+            .try_convert_to::<RString>()
+            .map_err(|e| VM::raise_ex(e))
+            .unwrap()
+            .to_string();
+
+        let mut client_builder = Client::builder();
+
+        if let Some(config_path) = config_path {
+            client_builder.config_path(config_path);
+        }
+
+        let client = client_builder
+            .access_key_id(access_key_id.clone())
+            .secret_access_key(secret_access_key.clone())
+            .account(account.clone())
+            .project(project.clone())
+            .watch_config(watch_config)
+            .profile(None)
+            .labels(labels)
+            .additional_connection_params({
+                let mut map = HashMap::<SmolStr, SmolStr>::new();
+                map.insert("client".into(), "ruby".into());
+                map.insert("wrapper_version".into(), CRATE_VERSION.into());
+                map
+            })
+            .build()
+            .map_err(|e| {
+                let exception = AnyException::new("ExogressError", Some(e.to_string().as_str()));
+                VM::raise_ex(exception);
+            })
+            .unwrap();
+
+        let (reload_config_tx, reload_config_rx) = mpsc::unbounded();
+        let (stop_tx, stop_rx) = oneshot::channel();
+
+        let instance = RustInstance {
+            client: parking_lot::Mutex::new(Some(client)),
+            reload_config_tx: parking_lot::Mutex::new(reload_config_tx),
+            reload_config_rx: Arc::new(parking_lot::Mutex::new(Some(reload_config_rx))),
+            stop_tx: parking_lot::Mutex::new(Some(stop_tx)),
+            stop_rx: Arc::new(parking_lot::Mutex::new(Some(stop_rx))),
+        };
+
+        Class::from_existing("Instance").wrap_data(instance, &*INSTANCE_WRAPPER)
+    }
+
+    fn spawn() -> NilClass {
+        let inner = itself.get_data(&*INSTANCE_WRAPPER);
+
+        let rt = Runtime::new().map_err(|e| {
+                let exception = AnyException::new("ExogressError", Some(e.to_string().as_str()));
+                VM::raise_ex(exception);
+            })
+            .unwrap();
+
+        let resolver = TokioAsyncResolver::from_system_conf(TokioHandle)
+            .map_err(|e| {
+                let exception = AnyException::new("ExogressError", Some(e.to_string().as_str()));
+                VM::raise_ex(exception);
+            })
+            .unwrap();
+
+
+        // let stop_rx = inner
+        //     .stop_rx
+        //     .lock()
+        //     .take()
+        //     .ok_or_else(|| {
+        //         let exception = AnyException::new("ExogressError", Some("instance has already been spawned"));
+        //         VM::raise_ex(exception);
+        //     })
+        //     .unwrap();
+
+        let work = || {
+            let resolver = resolver.clone();
+            let reload_config_tx = inner.reload_config_tx.lock().clone();
+            let reload_config_rx = inner.reload_config_rx.clone();
+            let stop_rx = inner.stop_rx.clone();
+
+            rt.block_on(async move {
+                println!("Spawn block_on");
+                if let (Some(client), Some(reload_config_rx), Some(stop_rx)) = (inner.client.lock().take(), reload_config_rx.lock().take(), stop_rx.lock().take()) {
+                    let spawn = client.spawn(reload_config_tx.clone(), reload_config_rx, resolver);
+
+                    tokio::select! {
+                        r = spawn => {
+                            println!("spawn stopped");
+                            if let Err(e) = r {
+                                return Err(anyhow::anyhow!(e.to_string()));
+                            }
+                        },
+                        _ = stop_rx => {
+                            println!("stop by request");
+                            // info!("stop exogress instance by request");
+                        }
+                    }
+                } else {
+                    return Err(anyhow::anyhow!("instance has already been spawned"));
+                }
+
+                Ok(())
+            })
+        };
+
+        let unblocking_function = || {};
+
+        let result = Thread::call_without_gvl(
+            work,
+            Some(unblocking_function)
+        );
+
+        result
+            .map_err(|e| {
+                let exception = AnyException::new("ExogressError", Some(e.to_string().as_str()));
+                VM::raise_ex(exception);
+            })
+            .unwrap();
+
+        NilClass::new()
+    }
+
+
+    fn reload() -> NilClass {
+        let inner = itself.get_data(&*INSTANCE_WRAPPER);
+
+        inner.reload_config_tx
+            .lock()
+            .unbounded_send(())
+            .map_err(|e| {
+                let exception = AnyException::new("ExogressError", Some(format!("failed to send reload request: {}", e).as_str()));
+                VM::raise_ex(exception);
+            })
+            .unwrap();
+
+        NilClass::new()
+    }
+
+    fn stop() -> NilClass {
+        let inner = itself.get_data(&*INSTANCE_WRAPPER);
+
+        inner.stop_tx
+            .lock()
+            .take()
+            .ok_or_else(|| {
+                let exception = AnyException::new("ExogressError", Some("instance already stopped"));
+                VM::raise_ex(exception)
+            })
+            .unwrap()
+            .send(())
+            .map_err(|_| {
+                let exception = AnyException::new("ExogressError", Some("failed to send reload request"));
+                VM::raise_ex(exception)
+            })
+            .unwrap();
+
+        NilClass::new()
+    }
+);

data/src/lib.rs

@@ -0,0 +1,17 @@
+#[macro_use]
+extern crate rutie;
+
+use rutie::{Class, Object, RString, VM};
+
+mod instance;
+
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn Init_rutie_exogress() {
+    Class::new("Instance", None).define(|klass| {
+        klass.def_self("new", instance::new);
+        klass.def("spawn", instance::spawn);
+        klass.def("reload", instance::reload);
+        klass.def("stop", instance::stop);
+    });
+}

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: exogress
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre.alpha.1
+platform: ruby
+authors:
+- Exogress Team
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rutie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Exogress is an edge network built for your cloud
+email:
+- team@exogress.com
+executables: []
+extensions:
+- Rakefile
+extra_rdoc_files: []
+files:
+- ".github/workflows/main.yml"
+- ".gitignore"
+- ".idea/.gitignore"
+- ".idea/exogress-ruby.iml"
+- ".idea/modules.xml"
+- ".idea/vcs.xml"
+- ".rspec"
+- Cargo.toml
+- Exofile.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- example/example.rb
+- exogress.gemspec
+- lib/exogress.rb
+- lib/exogress/version.rb
+- src/instance.rs
+- src/lib.rs
+homepage: https://exogess.com
+licenses:
+- Apache 2.0
+metadata:
+  homepage_uri: https://exogess.com
+  source_code_uri: https://github.com/exogress/exogress-ruby
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.2.15
+signing_key: 
+specification_version: 4
+summary: Exogress client for Ruby
+test_files: []