DEV Community: Njuguna Mureithi

🚀 Turbocharge Your Rust Project with plugins using plugy!

Njuguna Mureithi — Sat, 18 Nov 2023 11:47:35 +0000

Get ready to supercharge your Rust projects with plugy, the dynamic and playful plugin system that seamlessly integrates Rust-based plugins into your application. By providing a runtime environment for loading and executing WebAssembly (Wasm) plugins, plugy brings a new level of excitement and flexibility to your Rust development journey.

Features that Spark Joy in Your Rust Projects

Load and Execute Wasm Plugins: plugy lets you load and execute plugins compiled to WebAssembly, turning your Rust applications into dynamic powerhouses!
Flexible Runtime Management: Enjoy the freedom of flexible runtime management for your plugins, bringing dynamic extensibility without breaking a sweat.
Async Plugin Function Calls: plugy supports asynchronous plugin function calls, ensuring a smooth and entertaining integration of plugins into your async Rust applications.
Easy-to-Use Macros: Simplify the generation of plugin interfaces with plugy's snazzy macros, making the process of working with dynamic plugins as fun as a game.

🎮 Let the plugy Adventure Begin!

1. Define Your Plugin Trait

#[plugy::plugin]
trait Greeter {
    fn greet(&self) -> String;
}

2. Implement Your First Plugin

#[derive(Debug, Deserialize)]
struct FooPlugin;

#[plugin_impl]
impl Greeter for FooPlugin {
    fn greet(&self) -> String {
        "Hello From Foo Plugin".to_owned()
    }
}

Compile your plugin:

cargo build --target wasm32-unknown-unknown

3. Import and Run

#[plugin_import(file = "target/wasm32-unknown-unknown/debug/foo_plugin.wasm")]
struct FooPlugin;

#[tokio::main]
async fn main() {
    let runtime = Runtime::<Box<dyn Greeter>>::new().unwrap();
    let handle = runtime.load(FooPlugin).await.unwrap();
    let res = handle.greet().await;
    assert_eq!(res, "Hello From Foo Plugin")
}

And just like that, you're all set to embark on a dynamic extensibility adventure in your Rust project!

🚀 Examples for Practical Application

Explore the examples directory to find a thrilling use case that showcase the power and versatility of plugy in action.

🔓 Unlocking Functionality with plugy

plugy comprises three essential crates, each playing a distinct role in crafting dynamic plugin systems with Rust and WebAssembly:

core: This crate provides foundational components such as bitwise utilities and the guest module, forming the basis of plugy's functionality.
runtime: Orchestrating the execution of your plugin system, the runtime crate seamlessly integrates plugins into your applications, offering a smooth and efficient experience.
macros: The macros crate offers a collection of macros that simplify the generation of bindings and interfaces, making it easier to work with dynamic plugins.

🎉 Conclusion

With plugy, you're not just coding; you're on a journey of dynamic extensibility, unlocking new possibilities and embracing the flexibility that plugy brings to your Rust development. Happy coding and have a blast! 🚀✨

Github

https://github.com/geofmureithi/plugy

How to Create a Static Site Generator using Rust in less than 100 LOC

Njuguna Mureithi — Sat, 05 Aug 2023 12:18:51 +0000

In this tutorial, we will learn how to create a static site generator using Rust. We will use the following tools:

Rust (of course)
Markdown (Our content will be in markdown)
FrontMatter (Markdown content will contain YAML metadata)

Let's get started!

cargo new samosa-site

Create a new folder named pages inside samosa-site and move the following files into it:

index.md (The root of our site)
recipes/samosa-waru.md
recipes/samosa-beef.md

In the future, if we add more recipes, we expect the code to keep working.

Let's import some libraries in our Cargo.toml:

hirola = { version ="0.3", default-features = false, features = ["ssr"] } # For rendering html to string
glob = "0.3.1" # For searching through directories
comrak = { version = "0.18" } # For parsing markdown
fronma = "0.2" # For parsing front matter
serde = { version = "1", features = ["derive"] } # Required by fronma

Now, let's start writing some code:

Define Front Matter Content

#[derive(Debug, Deserialize)]
struct Seo {
    title: String
    //....
}

This would be read from markdown looking like this:

---
title: "A recipe for Beef samosas cooked Kenyan style"
---
# Kenyan style Beef samosas recipe
.....(more content here)

That done, let's now handle the layout for our site.
Here is a basic example but you should be able to write complex layouts

fn layout(seo: Seo) -> Dom {
    html! {
        <html>
            <head>
            <title>{&seo.title} " | Awesome Samosa Site"</title>
            <meta charset="utf-8"/>
            <meta property="og:title" content={&seo.title}/>
            </head>
            <body>
            // markdown content will go here
            "__MARKDOWN_CONTENT_HERE__"
            <body>
        </html>
    }
}

Reading Markdown Files

We will open a file, parse it, and return the HTML and Seo content in a tuple.

fn read_page(path: &PathBuf) -> (String, Seo) {
    use comrak::{markdown_to_html, ComrakOptions};
    let markdown = std::fs::read_to_string(path).unwrap(); // Open the path
    let data = fronma::parser::parse::<Seo>(&markdown)
        .expect(&format!("in file: {}", path.to_string_lossy())); // Parse front matter and markdown
    let res = markdown_to_html(&data.body, &ComrakOptions::default()); // convert markdown to html
    (res, data.headers)
}

Bringing it all together

fn main() {
    use glob::glob;
    for entry in glob("src/pages/**/*.md").expect("Failed to read glob pattern") {
        match entry {
            Ok(path) => {
                let (content, seo) = read_page(&path);
                let mut layout = "<!DOCTYPE html>".to_string();
                layout.extend(render_to_string(layout(seo)).chars());
                let html_path = path
                    .to_string_lossy()
                    .replace("src/pages", "dist")
                    .replace(".md", ".html");
                std::fs::create_dir_all("dist/recipes").unwrap();
                let file = File::create(&html_path).unwrap();
                let html_page = layout.replace("__MARKDOWN_CONTENT_HERE__", &content).as_bytes();
                file.write_all(html_page).expect("Unable to write data");

            }
            Err(e) => println!("{:?}", e),
        }
    }
}

That's it! Now, run cargo run --release and check the dist folder for your generated static site.

cd dist
python3 -m http.server

What next?

You can add a layout option in our Seo and frontmatter then use that to render different layouts

enum Layout {
    BlogPost,
    Recipe,
    ...
}
struct SeoFroma {
    title: String,
    layout: Layout
}

You can learn more about comrak and learn about plugins such as code highlighters.
You can learn more about hirola and learn how to write reactive UIs in Rust.

How to schedule and run cron jobs in Rust using apalis

Njuguna Mureithi — Sun, 14 Aug 2022 12:13:00 +0000

For this tutorial, we're going to use apalis to run cron jobs in an async context. We will also look at how to decorate our jobs with tower middleware allowing us to unlock features like retries, prometheus, sentry etc

To begin, we will want to:

Setup a new project

cargo new my-cron-scheduler
cd my-cron-scheduler

Add to Cargo.toml

[dependencies]
apalis = { version = "0.3", features = ["cron"] }
serde = { version = "1.0", features = ["derive"] }
tower = 0.4

In this tutorial we will create a daily reminder example.

use apalis::prelude::*;
use serde::{Serialize,Deserialize};

#[derive(Serialize, Deserialize, Default, Debug, Clone)]
struct Reminder;

// Define an apalis job
impl Job for Reminder {
    const NAME: &'static str = "reminder::DailyReminder";
}
// Define a handler
async fn send_reminder(job: Reminder, ctx: JobContext) {
    // Do reminder stuff
}

Lets define our entry point

use apalis::cron::{CronWorker, Schedule};
#[tokio::main]
async fn main() {
    // any valid cron string that points to the future should work
    let schedule = Schedule::from_str("@daily").unwrap();

    let worker = CronWorker::new(schedule, job_fn(send_reminder));

    Monitor::new()
        .register(worker)
        .run()
        .await
        .unwrap();
}

This works perfectly but we can add some more functionality eg retries and extensions to a job context.

To use these features by apalis, you need to include the retry and extension features.

use apalis::layers::{Extension, DefaultRetryPolicy, RetryLayer};

#[derive(Clone)]
struct FakeService;

let service = ServiceBuilder::new()
    // Will retry 25 times
    .layer(RetryLayer::new(DefaultRetryPolicy))
    .layer(Extension(FakeService))
    .service(job_fn(send_reminder));

let worker = CronWorker::new(schedule, service);

Monitor::new()
    .register(worker)
    .run()
    .await
    .unwrap();

Now we can access our FakeService in our handler

// Define a handler
async fn send_reminder(job: Reminder, ctx: JobContext) {
    let fake_service = ctx.data_opt::<FakeService>();
    // fake_service.fetch_from_db()
}

You can repeat the process for different cron jobs.

Monitor::new()
    .register(daily_worker)
    .register(weekly_worker)
    .run()
    .await
    .unwrap();

Further reading:
Background job processing with rust using apalis, actix and redis
Apalis on Github