Deliveroo分享从Ruby迁移到Rust提升17倍性能

#[macro_use]
extern crate rutie;

use rutie::{Class, Object, RString};

<b>class</b>!(HelloWorld);
methods!(
    HelloWorld,
    _itself,

    fn hello(name: RString) -> RString {
        RString::<b>new</b>(format!(<font>"Hello {}"</font><font>, name.unwrap().to_string()))
    }
);

#[allow(non_snake_<b>case</b>)]
#[no_mangle]
pub extern </font><font>"C"</font><font> fn Init_ruby_rust_demo() {
    let mut <b>class</b> = Class::<b>new</b>(</font><font>"RubyRustDemo"</font><font>, None);
    <b>class</b>.define(|itself| itself.def_self(</font><font>"hello"</font><font>, hello) );
}
</font>

pub struct RustUser {
    name: String,
    address: Address,
}

pub struct Address {
    pub country: String,
    pub city: String,
}

<b>class</b>!(User);

impl VerifiedObject <b>for</b> User {
    fn is_correct_type<T: Object>(object: &T) -> bool {
        object.send(<font>"class"</font><font>).send(</font><font>"name"</font><font>).<b>try</b>_convert_to::<RString>().to_string() == </font><font>"User"</font><font>
    }

    fn error_message() -> &'<b>static</b> str {
        </font><font>"Not a valid request"</font><font>
    }
}

methods!(
    </font><font><i>// .. some code skipped</i></font><font>

    fn hello(user: AnyObject) -> Boolean {
        let name = user.send(</font><font>"name"</font><font>).<b>try</b>_convert_to::<RString>().unwrap().to_string();
        let ruby_address = user.send(</font><font>"address"</font><font>);
        let country = ruby_address.send(</font><font>"country"</font><font>).<b>try</b>_convert_to::<RString>().unwrap().to_string();
        let city = ruby_address.send(</font><font>"city"</font><font>).<b>try</b>_convert_to::<RString>().unwrap().to_string();
        let address = Address {
            country,
            city
        };
        let rust_user = RustUser {
            name,
            address
        };
        <b>do</b>_something_with_user(&rust_user);
        Boolean::<b>new</b>(<b>true</b>)
    }
)
</font>

#[derive(Debug, Deserialize)]
pub struct User {
    pub name: String,
    pub address: Address,
}

#[derive(Debug, Deserialize)]
pub struct Address {
    pub country: String,
    pub city: String
}

<b>class</b>!(HelloWorld);
rutie_serde_methods!(
    HelloWorld,
    _itself,
    ruby_<b>class</b>!(Exception),

    <font><i>// Notice that the argument has our defined type `User`, and the return type is plain bool</i></font><font>
    fn hello_user(user: User) -> bool {
        <b>do</b>_something_with_user(&user);
        <b>true</b>
    }
);
</font>

module TravelTime
  def self.get(from_location, to_location, options)
    # in the real world the feature flag would be more granular and enable you to <b>do</b> an incremental roll-out
    <b>if</b> rust_enabled? && Feature.enabled?(:rust_travel_time)
        RustTravelTime.get(from_location, to_location, options)
    <b>else</b>
        RubyTravelTime.get(from_location, to_location, options)
    end
  end
end

RSpec.describe TravelTime <b>do</b>
  shared_examples <font>"travel_time"</font><font> <b>do</b>
    let(:from_location) { build(:location) }
    let(:to_location) { build(:location) }
    let(:options) { build(:travel_time_options) }

    it 'returns correct travel time' <b>do</b>
      expect(TravelTime.get(from_location, to_location, options)).to eq(123.45)
    end
  end

  context </font><font>"ruby implementation"</font><font> <b>do</b>
    before <b>do</b>
      Feature.disable!(:rust_travel_time)
    end

    include </font><font>"travel_time"</font><font>
  end

  context </font><font>"rust implementation"</font><font> <b>do</b>
    before <b>do</b>
      Feature.enable!(:rust_travel_time)
    end

    include </font><font>"travel_time"</font><font>
  end
end
</font>