Klausi's Weblog - rustnish

Mocking in Rust with conditional compilation

Klaus Purer — Sun, 31 Mar 2019 00:00:00 +0000
When writing automated unit tests for your application you will probably need to use mocks</a> at some point. Classical object-oriented programming languages such as PHP solve this with reflection where mock object types are created during test runtime. The code under test expects a certain interface or class and the test code passes mock objects that implement the interface or are a subclass.</p>

Benchmarking a Rust web application
Klaus Purer — Fri, 31 Aug 2018 00:00:00 +0000
Performance testing is an important part when developing a network application - you want to know when you have a regression in request throughput in your service.</p>
I set out out my goal 9 for Rustnish:</p>

Write benchmark code that compares runtime performance of Rustnish against
Varnish</a>. Use cargo bench</code> to execute the benchmarks.</p>
</blockquote>
The basic idea of a performance test here is to send many HTTP requests to the web service (the reverse proxy in this case) and measure how fast the responses arrive back. Comparing the results from Rustnish and Varnish should give us an idea if our performance expectations are holding up.</p>


Crashing a Rust Hyper server with a Denial of Service attack
Klaus Purer — Sun, 11 Mar 2018 00:00:00 +0000
I'm writing a reverse proxy in Rust using Hyper</a> and I want
to measure performance a bit to know if I'm doing something terribly wrong. By
doing that I discovered a Denial of Service vulnerability in Hyper when IO
errors are not properly handled. Note that a workaround has been released in
the meantime in Hyper
0.11.20</a>, more
background info can be found in this Hyper
issue</a>.</p>


Testing memory leaks in Rust
Klaus Purer — Fri, 06 Oct 2017 00:00:00 +0000
Rust has many built-in concepts for memory safety, but it cannot prevent
application level logic errors that take up system memory. An example would be
a server application that stores something for each incoming request in a
growing collection or list. If the program does not clean up the growing list
then it will take up more and more server memory - thereby exposing a memory
leak.</p>
While working on my reverse proxy project I discovered such a leak in the HTTP
library Hyper</a>. In order to
prevent and detect memory leaks in the future I set out my goal 7:</p>

Add an integration test that ensures that the proxy server is not leaking
memory (growing RAM usage without shrinking again). Use /proc information to
compare memory usage of the current process before and after the test.</p>
</blockquote>


Static variables made thread-safe in Rust
Klaus Purer — Sat, 09 Sep 2017 00:00:00 +0000
When writing integration tests for my Rustnish reverse proxy project</a> I
have hard-coded port numbers in tests. This is not ideal because it is hard to
keep track of which port numbers have already been used and which ones are
available when writing a new test. Because Rust's test runner executes test cases in parallel</a> it is important to coordinate
which test uses which ports so that there are no clashes that break the tests.</p>
One obvious solution to this problem would be to disable parallel test
execution with cargo test -- --test-threads=1</code>. But we want to cover program
and test isolation with our test so this is not really an option.</p>


Replacing unwrap() and avoiding panics in Rust
Klaus Purer — Wed, 16 Aug 2017 00:00:00 +0000
unwrap()</code></a> is a useful tool in Rust but is also bad practice in production code that
should not abort with unpredictable panics.</p>
Therefore my goal 4 for Rustnish is full integration tests with no panics
allowed:</p>

Expand the integration tests to confirm that the reverse proxy is working as
expected. Add tests with broken HTTP requests to cover error handling of the
reverse proxy. All unwrap()</code> calls in none test code should be removed
and covered by proper error handling.</p>
</blockquote>


Converting a Hyper server to Tokio
Klaus Purer — Sun, 16 Jul 2017 00:00:00 +0000
Since my first blog post where I constructed a server with Hyper</a> some time
has passed and there is now a new version of the library that is based on
Tokio</a>. My goal 3:</p>

A new version of the Hyper library has been released which is
based on the Tokio library. Convert the existing code to use that new version
and provide one integration test case.</p>
</blockquote>
Tokio handles input/output asynchronously, which makes setting up a server more
complicated. The benefit is more efficient parallel execution with a
non-blocking event loop.</p>


Using Visual Studio Code for Rust on Ubuntu
Klaus Purer — Sun, 28 May 2017 00:00:00 +0000
I already wrote about using Eclipse for Rust development</a> but after trying
Visual Studio Code</a> (VSCode) I think it is
slightly better than the Eclipse integration:</p>

when the cursor is at a variable the same variable is highlighted elsewhere.</li>
tooltip popups when hovering over variables, functions, methods.</li>
better native support for Git and Markdown files</li>
</ul>
Syntax highlighting, autocompletion, Ctrl + Click on functions and
auto-formatting of course also work in VSCode as you would expect from an IDE.</p>


Writing integration tests in Rust
Klaus Purer — Thu, 25 May 2017 00:00:00 +0000
In my first post I wrote a quite fragile, minimally working prototype that uses
many unwrap()</code> calls thereby raising lots of panics during execution.
Implementing and verifying proper error handling requires testing. I don't want
to do unit testing yet because that would require research about complicated
mocking techniques and dependency injection in Rust. Instead, I would like to
do integration testing of the whole application to prove that the end result is
working as expected.</p>


Using Eclipse IDE for Rust on Ubuntu
Klaus Purer — Sat, 06 May 2017 00:00:00 +0000
Update: New blog post about choosing Visual Studio Code for Rust</a>
because of better IDE support.</strong></p>
In my first blog post</a> I was
starting out with Atom editor but quickly realized that it is lacking features
of Integrated Development Environments (IDEs). I need to be able to click on
functions and data types to jump to their definitions and was not able to get
that working in Atom.</p>


Getting started with Rust
Klaus Purer — Sun, 30 Apr 2017 00:00:00 +0000
</p>
Rust</a> is still very alien to me and I want to write
a bit of code in it to get a feeling of the concepts and restrictions it
enforces.</p>