Joel's Journal

Dockerizing my Jekyll Blog

Mon, 22 Jan 2018 12:54:09 -0500

1. Background
2. End Goal
3. Lessons
4. Conclusion

Over the last several months, I have been using Docker more and more at work.

I have been wanting to apply it to something personal, and dockerizing my blog just made sense. There were a number of weaknesses in the way my current blog works I wanted to address.

As I worked through it, I ran into enough "gotchas" that I thought a more thorough writeup was worth doing. ¹ Hopefully I can help someone else who is new-ish to docker (or, more honestly, hopefully I stop making some of these mistakes myself).

1 Background

tl;dr basically I have two services that need to run, jekyll and an org-mode compiler service.

Over time, I have grown less-and-less satisfied with Jekyll (and Markdown, especially). I really wanted author posts in org-mode. Of course, there are several solutions that exist for this, but the only one with the featues I wanted is the official implementation. So, I wrote a little org-mode compilation service. A while ago I wrote about the initial implementation. That ended up being unacceptably slow, so I hacked together a little TCP service that vastly improved performance. ²

2 End Goal

I wanted to have two separate containers, one running Jekyll, and the other running the Emacs service. Additionally, I want the potential to add more services in the future.

The theoretical of attaining this is short to describe:

Find or build an image for each services' container.
Experiment to find the correct container configuration for the services to run together.
1. Modify the application code in each service to facilitate the dockerization, if necessary.
Combine these configurations into a docker-compose file.
Test, iterate, and use.

As I alluded to earlier, this is harder than it sounds.

3 Lessons

3.1 When building docker images, look for existing `Dockerfile` examples

Sometimes, there might be a Docker image that does exactly what you need it to, and you won't have to build a custom image. For me, this has rarely been the case.

In the case of my Jekyll image, I couldn't find an existing image that did what I wanted. The mistake I made at this point was to try to figure it out without looking for any resources. I quickly ran into issues.

In fact, I have consistently found it surprisingly hard to dockerize software. I always run into some unexpected environment issues – probably largely because of "minimal" base images³, but there may be other issues in play.

Surprisingly (to me, at least), I found an emacs image that was perfect for my use. I used it as a base images to build the org compilation service.

3.2 Inter-application communication is trickier

When something runs on my machine, my default "go-to" solution is to use localhost. This has tripped me up a few times, since services in separate containers are not on the same localhost. Components will often need to be reconfigured (for example, a service may need to listen on 0.0.0.0 instead of localhost, and a client may need to connect to a the containers name, instead of localhost).

This is good to keep in mind, because when you run into it, if this is the problem you will have a much easier time than going through all the steps to debug your network connectivity.

3.3 Use an entrypoint script

When building docker images, it is MUCH easier to have an entrypoint script than to attempt a complicated invocation within the Dockerfile's CMD or ENTRYPOINT settings. I have made this mistake several times. The syntax that CMD and ENTRYPOINT accept is weird. It can be really non-obvious when these are not correct. Just use a run (or entrypoint) script to run your container's application code.

3.4 Docker tools are weird

Docker is an awesome tool, but I find many of its design decisions surprisingly limiting. I don't know how else to say it besides that. Why can't I start an existing, stopped container with a different command than what it was created with? Why is it so hard to encode compilcated scenarios in docker-compose.yml files?

In the end, I ended up with two separate docker-compose.yml, and the only differences between each of them is that one uses a different jekyll command from the other. I also have three separate shell scripts in the bin directory which provide a nicer interface for:

Serving the site with Jekyll in drafts mode.
Serving the production version of the site.
Building and deploying the site.

Could I possibly have simplified this into fewer pieces? I am sure I will in the future. But at the moment I've hit enough problems figuring out how to do that that I just want to get some work done.

4 Conclusion

I don't want to come across as overly negative about Docker. It is an incredible tool that has rightly received a lot of hype. Even though parts of it are awkward to work with, containerized applications are just so nice that I believe the pain is well worth it.

Footnotes:

I keep telling myself that I need to write these things as I work on and learn things. And, I keep not doing it. Here I am trying to break that pattern.

At one point I wanted to write about that experience, which was actually kinda interesting (This was the first "raw tcp" service I had ever written that was useful (as opposed to being a learning experience). There are a few interesting pieces:

The Jekyll plugin written in Ruby which starts and stops the org-mode compilation service, and the org-mode service that receives the raw org-mode text over a socket and responds with the compiled html version.

Part of that support was code for automatically starting the required emacs process, so the service would be ready when Jekyll needed it. This was tricky though and had bugs. As I learned Docker, it quickly became clear that it would work better as a separate service specified in a docker-compose file.

with a small base image, you end up needing to specify everything for your app. In my experience, an app that runs easily on regular ubuntu 16.04 does not mean it works on the ubuntu:16.04 image just as easily, for example.

Eventually I looked at the repo I had evaluated ealier (https://github.com/envygeeks/jekyll-docker), which I was able to use as an example. What I ended up with (https://github.com/joelmccracken/joelmccracken.github.com/blob/writing/_jekyll-image/Dockerfile) was way more complicated than I initially expected! ⁴

⁴

Some of it is probably unnecessary and cargo-culted, but I tried pulling some of it out and ran into issues (e.g. not running as jekyll user).

A Simple Web App in Rust, Conclusion: Putting Rust Aside for Now

Fri, 29 Dec 2017 22:48:58 -0500

Warning: this whole piece is full of opinion. It probably isn't surprising to anyone in the Rust community, but I want punctuate the series.

Several years ago, I worked on a series of blog posts entitled "Building a Simple Webapp in Rust". I hoped to return to it at some point, but I have not, and I doubt I ever will finish the series – at this point, almost everything in the post is probably out of date.

In one important sense, the project was a success: I learned a ton about Rust.

I did eventually stop the project, and stop learning Rust. Why? In short, I began to doubt that Rust held enough value for me versus other avenues of interest. It is clear to me that Rust is a great language for situations that require tight control over the hardware and performance. Given a project with these requirements, I would absolutely start using Rust again. If I had any situation where I would otherwise write C++, I would use Rust.

However, hardware control is not the most important factor in most of the software I write. I never write software in C++. Clarity and maintainability are the most important factors, balanced against development time. Performance issues can almost always be addressed after the software works, by performance testing and making smart optimizations.

There was one compelling reason for me to continue investigating Rust: I have heard some say Rust is the most productive language for them, and they believe this would apply to programmers in general. The reasoning goes that the ownership system makes them think more about their code, and in some ways significantly influences design for the better. I think this is quite possible, but I am not convinced enough to invest a significant amount of time in Rust. I think my time is best spent elsewhere.

Ultimately, I decided that my time would be better spent learning other things. Specifically, Haskell (by way of Elm initially) and other languages with powerful effects systems.

—

Series: A Simple Web App in Rust

Writing a 'Human Resource Machine' Emulator in Elm

Sun, 05 Jun 2016 22:01:24 -0400

1. Goals and Ideas
2. MVP
3. The Program

I'm working on an Elm emulator for the the game Human Resource Machine. The goal of the game is to use a sort of "assembly-like" language to control a character and have them perform requested tasks. The player puts commands together by dragging commands around as blocks. Its a basically a "visual" assembly language. The levels in the game have been fun and challenging enough to keep me interested.

Each level is presented as a conveyor belt inbox, a conveyor belt outbox, and some place to work with. The player is asked to transform the input in some way, using the commands that are available for this level.

I thought it would be a fun exercise to write an emulator for the the game in Elm. I want to fix a number of usability issues I see in the game. Also, I've been wanting to learn to write games. While this isn't a game, it is closely tied to a game, and I think it addresses the same desire.

I'm still learning Elm, so this code probably has many flaws. Still, I believe it is useful to see things through my eyes, as they are, now. If you notice something that could be better, please, let me know in the comments.

1 Goals and Ideas

What would make a good online emulator, something that people might find worth using?

The HRM editor is very basic. While good, I find it frustrating because of the inability to write comments, among other things. Later on in the game, you gain the ability to create little comment-y slips of paper, but this requires you to actually "draw" the words with your mouse/trackpad. It is really, really bad. I'd much rather work with "normal" comments, and there is no practical reason
Instead of working with text, in HRM you drag around boxes with words in them. This is more akin to programming with the MIT scratch project than traditional programming. This is OK, and I think it is a good idea for beginners, but I personally want to write text.

2 MVP

I first wanted to write a "proof-of-concept", from which I can add more features, over time.

The smallest design that I could come up with for this proof-of-concept is:

Only emulate the first level, which has the most basic set of instructions.
Each second, apply the next instruction to the machine status.
Show the machine status after each instruction is calculated.

The first level consists of a simple task: For each item on an inbox conveyor belt, place it on the outbox conveyor belt. We are given two possible instructions: 'inbox', and 'outbox'. The 'inbox' command instructs the character to pick something up off the inbox and hold it in their hands. The 'outbox' command says to place whatever is being held on the outbox.

3 The Program

Lets go through the solution, piece by piece, starting with the most straightforward pieces first.

3.1 Model

The easiest way to represent instructions is as a Union type:

type Instruction = Inbox
		 | Outbox

Hard-coding the solution program as an array of instructions makes this proof of concept easier:

program : Array Instruction
program =
  Array.fromList
	 [ Inbox
	 , Outbox
	 , Inbox
	 , Outbox
	 , Inbox
	 , Outbox
	 ]

It seems like every Elm program has a "Model" type, and this is no exception:

import Array exposing (Array)

type alias Model =
    { program : Array Instruction
    , status  : MachineStatus
    }

So, model is a combination between a program and an emulated "machine".

There is some forward thinking going on in this design. The model could be slightly simpler for this MVP, but part of the goal of this iteration is to explore what the solution may look like in the future.

program is listed as part of the model, although it needn't be in this case, since it is hard-coded and won't change. However, we want this to be different very soon, so it makes sense to just put this on the model, for now.
status is a separate type because in the future I want to maintain a list of all statuss, for debuggability. It becomes just a little easier to refactor to a list if it is separate, and allows for a little bit of exploration of what a MachineStatus type should contain.

type alias MachineStatus =
    { status : Status
    , held   : Maybe Value
    , input  : List Value
    , output : List Value
    , pc     : Int
    }

type Status = Running | Complete | Error String

status signifies execution completion. I strongly suspect that this will go somewhere else, as it feels strange to have it in here. But, this is OK for now.
held represents the current value that is being held. In HRM, what you hold is akin to a CPU register; your character do calculations with and moves values to and from their hands – which, really, is just like real life. This is a Maybe because it is possible for the hands to be empty.
input represents the input conveyor. Values are taken from it and manipulated.
output represents the output conveyor, onto which values are placed.
pc represents the "program counter". This is the index of the next instruction to be executed.

You may notice that the above references a Value. This is the "values" that may be worked with in the game:

type Value = Int

For now, we are only working with integers.

3.2 Program Scaffolding & View

I'm not sure where to mention this, but I want to include here the bits and pieces that make the program actually run. I think its helpful to get them out of the way.

import Html.App as Html

main : Program Never
main =
  Html.program { init = init, view = view, update = update, subscriptions = subscriptions }

The program is an Html.program, with the basic wiring.

import Time exposing (Time, second)

subscriptions : Model -> Sub Msg
subscriptions model =
  Time.every second Tick

Tick each second. The only input the program receives for now are ticks.

The view can also be made fairly simple:

import Html exposing (Html, div, text)


-- VIEW

renderState : MachineState -> Html a
renderState state =
    div [] [text (toString state)]


view : Model -> Html Msg
view model =
  div []
    [ div [] [text (toString model.program)]
    , renderState model.state
    ]

Instead of worrying about anything very complicated, we just use Elm's toString method to create a user-readable version of the data structure.

3.3 The Update

The "meat" of the application is the update functionality. This is the code that actually emulates the machine.

With our types defined, the code is not necessarily overly-complicated:

-- UPDATE

type Msg
  = Tick Time


update : Msg -> Model -> (Model, Cmd Msg)
update action model =
  case action of
    Tick newTime ->
	let
	    isComplete = model.state.status
	in
	    case isComplete of
		Running -> (stepModel model, Cmd.none)
		_       -> (model, Cmd.none)

The function update is the main loop. On each tick of the clock, apply an instrution and compute the next version of the model if the machine is still running.

I didn't point this out earlier, but there are two other status types: Complete and Error String. Complete indicates that the program completed successfully, and is no longer running. Error String provides a way to report an error if the program tries to do something invalid, such as:

Finish without the correct values being on the output conveyor.
Tries to pick up something from the input conveyor when the conveyor is empty.
Tries to place something on the output conveyor when the character is not holding anything.

Although, there are others. Next up, stepModel, which is where things begin to get interesting.

stepModel : Model -> Model
stepModel model =
  let curr = currentInstruction model.program model.state.pc
  in case curr of
    Just instruction  ->
      processInstruction instruction model
    Nothing        ->
      updateState model (\s-> { s | status = Error "The machine attempted to access an invalid instruction."})

Before calculating the next state, Calculating the next value of the model involves:

Finding the current instruction to execute.
Performing a specific action based upon the current instruction.
Performing some bookkeeping: Move to the next counter, complete the state if the program has finished, etc.

Lets look at each of these functions, one at a time.

currentInstruction : Array Instruction -> Int -> Instruction
currentInstruction instructions pc =
  case (Array.get pc instructions) of
    Just a  -> a
    Nothing -> Debug.crash "you're trying to access an instruction that doesn't exist"

This is one of those situations where a type system makes things interesting. I wouldn't have thought about Array.get possibly failing without it returning a Maybe, which I then have to deal with.

updateState : Model -> (MachineState -> MachineState) -> Model
updateState model updater =
    let newState = updater model.state
    in { model | state = newState }


stepPC : Model -> Model
stepPC model =
    updateState model (\s-> {s | pc = s.pc + 1 })


completeIfFinished : Model -> Model
completeIfFinished model =
  let programLength = Array.length model.program
      pc = model.state.pc
  in if pc < programLength then
	 model
     else
	 updateState model complete


shiftInboxToHands : Model -> Model
shiftInboxToHands model =
  let first = List.head model.state.input
      rest  = case List.tail model.state.input of
		Just r  -> r
		Nothing -> []
  in case first of
       Just val ->
	   updateState model (\s-> { s | held = Just val, input = rest})
       Nothing -> updateState model (\s-> {s | status = Error "tried to pick up an item from the inbox, but inbox was empty" })


-- state manipulators

complete : MachineState -> MachineState
complete state = { state | status = Complete }


shiftHandsToOutbox : Model -> Model
shiftHandsToOutbox model =
  let currentState = model.state
  in case model.state.held of
    Nothing  -> updateState model complete
    Just val -> { model | state =
		     { currentState
			 | held = Nothing,
			   output  = (val :: currentState.output)
		     }}

stepModel : Model -> Model
stepModel model =
  let curr = currentInstruction model.program model.state.pc
  in case curr of
    Inbox ->
      shiftInboxToHands model |> stepPC |> completeIfFinished
    Outbox ->
      shiftHandsToOutbox model |> stepPC |> completeIfFinished

Homebrew Command `brew leaves`: List Packages Without Dependents

Wed, 18 May 2016 22:02:12 -0400

Have you ever wondered what packages you've installed via Homebrew? You know, the ones that you've actually purposefully installed:

brew install <whatever>

I have always wanted this, for a number of reasons, but one of the main reasons is to quickly see what software I have installed on my machine.

To be clear, brew leaves doesn't actually show what you have manually installed, but it shows the commands that have no dependents. leaves is a reasonable approximation of this, though.

Additionally, I like to use the command as a quick way to show things that I can probably remove from my system without worry. Something I use that isn't in homebrew might still use the package, but you'll have that.

—

Sometimes, you just miss things in documentation. I've looked at the brew man page a number of times while this feature has been in homebrew, and I haven't ever noticed it. I'm not sure if it was a product of poor searching, or me reading it and not comprehending it. The man page says this for the leaves subcommand:

Show installed formulae that are not dependencies of another installed formula.

You live and you learn.

How to Print a Struct in Rust

Wed, 30 Sep 2015 00:00:00 -0400

So, you're programming in Rust, and one day you think it would be really nice to be able to display a printed version of your structure in memory.

This is one of the handier things I've learned to do while working with Rust. I use it all the time, and while I've memorized the pattern, I don't want to forget again.

So, here it is:

#[derive(Debug)]
struct User {
    name: String,
    id: i32
}

fn main() {
    let user = User { name: "Gary".to_string(), id: 1234 };
    println!("{:?}", user);
}

Compiling and running:

$ rustc print-struct.rs
$ ./print-struct
User { name: "Gary", id: 1234 }

Lets look at the pieces:

Add #[derive(Debug)] above the struct definition to have rust extend the debug trait.
Use {:?} inside your println! format string instead of the usual {}.

That's it! It is really simple, but it makes development sooo much easier.

A Simple Web App in Rust, Part 4 -- CLI Option Parsing

Sat, 08 Aug 2015 00:00:00 -0400

1. Back from Hiatus
2. Intro
3. Requirements
4. Implementation
5. A Rant
6. Continuing
7. More Debugging
8. Regrouping
9. Refactoring
10. Conclusions & Retrospective on Part 4

1 Back from Hiatus

Hello! Sorry for the delay in this one. My wife and I just bought a house, and we have been dealing with all that. Thanks for your patience.

2 Intro

Last time, we built a "working" application; the proof-of-concept is there. In order to make it into something that could actually be used, we need to worry about some other things like adding command line options.

So, I'm going to do some command parsing. But first, lets move this existing code out of the way to have a "blank slate" to do some CLI parsing experimentation. But, even before that, lets just generally clean things up a bit by removing some old files, and then creating a new main.rs:

$ ls
Cargo.lock      Cargo.toml      log.txt         src             target
$ cd src/
$ ls
main.rs                 main_file_writing.rs    web_main.rs

main_file_writing.rs and web_main.rs are both old, so I can remove them. After that I'll move main.rs to, say, main_logging_server.rs and create a new main.rs.

$ git rm main_file_writing.rs web_main.rs
rm 'src/main_file_writing.rs'
rm 'src/web_main.rs'
$ git commit -m 'remove old files'
[master 771380b] remove old files
 2 files changed, 35 deletions(-)
 delete mode 100644 src/main_file_writing.rs
 delete mode 100644 src/web_main.rs
$ git mv main.rs main_logging_server.rs
$ git commit -m 'move main out of the way for cli parsing experiment'
[master 4d24206] move main out of the way for cli parsing experiment
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/{main.rs => main_logging_server.rs} (100%)
$ touch main.rs

On to parameter parsing. In the comments section of an earlier post, Stephan Sokolow asked if I had considered using the package clap for command line parsing. Clap looks interesting, so, I'll try it.

3 Requirements

The service needs to be parameterized for the following:

The location of the log file.
A secret token to authenticate with.
(Possibly) setting the time zone to use with logging.

I just checked the Digital Ocean VM that I'm planning to use this on, and the machine is in EST, which is also my time zone, so I'll probably skip number 3, for now.

4 Implementation

As far as I can tell, the way to specify this dependency is via clap = "*";. I'd always rather specify one, specific version, but for now "*" will work.

My new Cargo.toml:

[package]
name = "simple-log"
version = "0.1.0"
authors = ["Joel McCracken <mccracken.joel@gmail.com>"]

[dependencies]

chrono = "0.2"
clap   = "*"

[dependencies.nickel]

git = "https://github.com/nickel-org/nickel.rs.git"

Installing the dependency:

$ cargo run
    Updating registry `https://github.com/rust-lang/crates.io-index`
 Downloading ansi_term v0.6.3
 Downloading strsim v0.4.0
 Downloading clap v1.0.0-beta
   Compiling strsim v0.4.0
   Compiling ansi_term v0.6.3
   Compiling clap v1.0.0-beta
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
error: main function not found
error: aborting due to previous error
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

The error is just because my main.rs file is still empty; the important part is that the "Compiling clap" things look good.

Based upon the README, I'll try the very simple version listed:

extern crate clap;
use clap::App;

fn main() {
  let _ = App::new("fake").version("v1.0-beta").get_matches();
}

Running:

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
     Running `target/debug/simple-log`
$ cargo run
     Running `target/debug/simple-log`
$ cargo build --release
   Compiling lazy_static v0.1.10
   Compiling matches v0.1.2
   Compiling bitflags v0.1.1
   Compiling httparse v0.1.2
   Compiling strsim v0.4.0
   Compiling rustc-serialize v0.3.14
   Compiling modifier v0.1.0
   Compiling libc v0.1.8
   Compiling unicase v0.1.0
   Compiling groupable v0.2.0
   Compiling regex v0.1.30
   Compiling traitobject v0.0.3
   Compiling pkg-config v0.3.4
   Compiling ansi_term v0.6.3
   Compiling gcc v0.3.5
   Compiling typeable v0.1.1
   Compiling unsafe-any v0.4.1
   Compiling num_cpus v0.2.5
   Compiling rand v0.3.8
   Compiling log v0.3.1
   Compiling typemap v0.3.2
   Compiling clap v1.0.0-beta
   Compiling plugin v0.2.6
   Compiling mime v0.0.11
   Compiling time v0.1.25
   Compiling openssl-sys v0.6.2
   Compiling openssl v0.6.2
   Compiling url v0.2.34
   Compiling mustache v0.6.1
   Compiling num v0.1.25
   Compiling cookie v0.1.20
   Compiling hyper v0.4.0
   Compiling chrono v0.2.14
   Compiling nickel v0.5.0 (https://github.com/nickel-org/nickel.rs.git#69546f58)
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)

$ target/debug/simple-log --help
simple-log v1.0-beta

USAGE:
        simple-log [FLAGS]

FLAGS:
    -h, --help       Prints help information
    -V, --version    Prints version information

$ target/release/simple-log --help
simple-log v1.0-beta

USAGE:
        simple-log [FLAGS]

FLAGS:
    -h, --help       Prints help information
    -V, --version    Prints version information

I don't know why the readme told me to compile with --release – it looks like the debug worked the same way. Unless I don't understand what's going on. Lemmie rm the target dir, then try again without the release flag:

$ rm -rf target
$ ls
Cargo.lock      Cargo.toml      log.txt         src
$ cargo build
   Compiling gcc v0.3.5
   Compiling strsim v0.4.0
   Compiling typeable v0.1.1
   Compiling unicase v0.1.0
   Compiling ansi_term v0.6.3
   Compiling modifier v0.1.0
   Compiling httparse v0.1.2
   Compiling regex v0.1.30
   Compiling matches v0.1.2
   Compiling pkg-config v0.3.4
   Compiling lazy_static v0.1.10
   Compiling traitobject v0.0.3
   Compiling rustc-serialize v0.3.14
   Compiling libc v0.1.8
   Compiling groupable v0.2.0
   Compiling bitflags v0.1.1
   Compiling unsafe-any v0.4.1
   Compiling clap v1.0.0-beta
   Compiling typemap v0.3.2
   Compiling rand v0.3.8
   Compiling num_cpus v0.2.5
   Compiling log v0.3.1
   Compiling time v0.1.25
   Compiling openssl-sys v0.6.2
   Compiling plugin v0.2.6
   Compiling mime v0.0.11
   Compiling openssl v0.6.2
   Compiling url v0.2.34
   Compiling num v0.1.25
   Compiling mustache v0.6.1
   Compiling cookie v0.1.20
   Compiling hyper v0.4.0
   Compiling chrono v0.2.14
   Compiling nickel v0.5.0 (https://github.com/nickel-org/nickel.rs.git#69546f58)
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
$ target/release/simple-log --help
bash: target/release/simple-log: No such file or directory
$ target/debug/simple-log --help
simple-log v1.0-beta

USAGE:
        simple-log [FLAGS]

FLAGS:
    -h, --help       Prints help information
    -V, --version    Prints version information
$

So, I guess you don't need that --release flag. Ya learn something new every day.

Also, looking at the main code again, I notice that the variable is named _; I assume this must be in order to silence warnings/signify disuse. Using _ to signify "intentionally unused" is pretty standard, I like that Rust supports this.

So, based upon the clap readme and a little experimentation, I've come up with this first attempt at writing an argument parser:

extern crate clap;
use clap::{App,Arg};

fn main() {
    let matches = App::new("simple-log").version("v0.0.1")
        .arg(Arg::with_name("LOG FILE")
             .short("l")
             .long("logfile")
             .takes_value(true))
        .get_matches();

    println!("Logfile path: {}", matches.value_of("LOG FILE").unwrap());

}

$ cargo run -- --logfile whodat
     Running `target/debug/simple-log --logfile whodat`
Logfile path: whodat
$ cargo run -- -l whodat
     Running `target/debug/simple-log -l whodat`
Logfile path: whodat

Ok, so that worked! But here's a problem:

$ cargo run
     Running `target/debug/simple-log`
thread '<main>' panicked at 'called `Option::unwrap()` on a `None` value', /private/tmp/rust2015051
6-38954-h579wb/rustc-1.0.0/src/libcore/option.rs:362
An unknown error occurred

To learn more, run the command again with --verbose.

So. Calling unwrap() up there was a bad idea, since this argument may not be passed in!

I'm not sure what the opinion of the greater Rust community is on unwrap, but everywhere I've noticed it there is also a comment explaining why it should be OK to use here. While I think that makes sense, as an application grows it is easy for assumptions in one place to become invalidated. And, notice that the error occurs at run-time. This isn't something that the compiler can determine!

Is unwrap the same basic idea as there being a null pointer exception? I think so. But, it does make you stop and think about what you're doing, and if it means that unwrap is a code sort-of-smell, then that's great. Which leads me to a bit of a rant:

5 A Rant

I firmly believe that you cannot make developers write good code. The problem I have with static language communities is that the rhetoric around these programming languages: that they will "prevent the programmer from doing bad things". Well, guess what: that's impossible.

Firstly, you cannot define "good code" in any sensible way. Indeed, much of what makes code good is highly context-dependent. As a very basic example, sloppy code is good when prototyping, but sloppy code is horrible when making something production-quality.

The latest OpenSSL vulnerability is a great example of this. I didn't read very much into the news about the vulnerability, but from what I gathered, the cause of the bug was an error in business logic. Under certain very-specific circumstances, an attacker could become a certificate authority. How do you write a compiler that prevents this problem?

Indeed, this takes me back to an old quote from Charles Babbage:

On two occasions I have been asked, "Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out?" In one case a member of the Upper, and in the other a member of the Lower, House put this question. I am not able rightly to apprehend the kind of confusion of ideas that could provoke such a question.

The best thing that you can do is make it easier for developers to write good code. Doing the right thing should be the normal, easy path.

Once you start talking about static type systems as tools to make programming easier, I think things start to make sense again. In the end, the developer is still responsible for doing the right thing, and we must trust them and empower them to do these things.

Finally: the programmer can always implement a little Scheme interpreter and write all their application logic in that. Good luck trying to get your type checker to prevent that sort of thing.

Ok, I'm done. I'll get down off my soapbox. Thanks for indulging me.

6 Continuing

Back in the real world, I notice that there is an option for an Arg that specifies that the argument is required. I think I'd like to use that here:

extern crate clap;
use clap::{App,Arg};

fn main() {
    let matches = App::new("simple-log").version("v0.0.1")
        .arg(Arg::with_name("LOG FILE")
             .short("l")
             .long("logfile")
             .required(true)
             .takes_value(true))
        .get_matches();

    println!("Logfile path: {}", matches.value_of("LOG FILE").unwrap());

}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
     Running `target/debug/simple-log`
error: The following required arguments were not supplied:
        '--logfile <LOG FILE>'

USAGE:
        simple-log --logfile <LOG FILE>

For more information try --help
An unknown error occurred

To learn more, run the command again with --verbose.
$ cargo run -- -l whodat
     Running `target/debug/simple-log -l whodat`
Logfile path: whodat

It works! The next we need option is to specify a secret token via the command line. Lets add that, but make it optional because, well, why not? I might want to put up an open version of this for people to see.

I'm left with this:

extern crate clap;
use clap::{App,Arg};

fn main() {
    let matches = App::new("simple-log").version("v0.0.1")
        .arg(Arg::with_name("LOG FILE")
             .short("l")
             .long("logfile")
             .required(true)
             .takes_value(true))
        .arg(Arg::with_name("AUTH TOKEN")
             .short("t")
             .long("token")
             .takes_value(true))
        .get_matches();

    let logfile_path = matches.value_of("LOG FILE").unwrap();
    let auth_token   = matches.value_of("AUTH TOKEN");
}

$ cargo run -- -l whodat
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:17:9: 17:21 warning: unused variable: `logfile_path`, #[warn(unused_variables)] on by d
efault
src/main.rs:17     let logfile_path = matches.value_of("LOG FILE").unwrap();
                       ^~~~~~~~~~~~
src/main.rs:18:9: 18:19 warning: unused variable: `auth_token`, #[warn(unused_variables)] on by default
src/main.rs:18     let auth_token   = matches.value_of("AUTH TOKEN");
                       ^~~~~~~~~~
     Running `target/debug/simple-log -l whodat`

There are a lot of (expected) warnings, but it compiles and runs fine. I just wanted it to type-check. Now lets bring this back to the real program. I start with the code below:

use std::io::prelude::*;
use std::fs::OpenOptions;
use std::io;

#[macro_use] extern crate nickel;
use nickel::Nickel;

extern crate chrono;
use chrono::{DateTime,Local};

extern crate clap;
use clap::{App,Arg};

fn formatted_time_entry() -> String {
    let local: DateTime<Local> = Local::now();
    let formatted = local.format("%a, %b %d %Y %I:%M:%S %p\n").to_string();
    formatted
}

fn record_entry_in_log(filename: &str, bytes: &[u8]) -> io::Result<()> {
    let mut file = try!(OpenOptions::new().
                        append(true).
                        write(true).
                        create(true).
                        open(filename));
    try!(file.write_all(bytes));
    Ok(())
}

fn log_time(filename: &'static str) -> io::Result<String> {
    let entry = formatted_time_entry();
    {
        let bytes = entry.as_bytes();

        try!(record_entry_in_log(filename, &bytes));
    }
    Ok(entry)
}

fn do_log_time(logfile_path: &'static str, auth_token: Option<&str>) -> String {
    match log_time(logfile_path) {
        Ok(entry) => format!("Entry Logged: {}", entry),
        Err(e) => format!("Error: {}", e)
    }
}

fn main() {
    let matches = App::new("simple-log").version("v0.0.1")
        .arg(Arg::with_name("LOG FILE")
             .short("l")
             .long("logfile")
             .required(true)
             .takes_value(true))
        .arg(Arg::with_name("AUTH TOKEN")
             .short("t")
             .long("token")
             .takes_value(true))
        .get_matches();

    let logfile_path = matches.value_of("LOG FILE").unwrap();
    let auth_token   = matches.value_of("AUTH TOKEN");

    let mut server = Nickel::new();

    server.utilize(router! {
        get "**" => |_req, _res| {
            do_log_time(logfile_path, auth_token)
        }
    });

    server.listen("127.0.0.1:6767");
}

$ cargo run -- -l whodat
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:60:24: 60:31 error: `matches` does not live long enough
src/main.rs:60     let logfile_path = matches.value_of("LOG FILE").unwrap();
                                      ^~~~~~~
note: reference must be valid for the static lifetime...
src/main.rs:58:24: 72:2 note: ...but borrowed value is only valid for the block suffix following st
atement 0 at 58:23
src/main.rs:58         .get_matches();
src/main.rs:59
src/main.rs:60     let logfile_path = matches.value_of("LOG FILE").unwrap();
src/main.rs:61     let auth_token   = matches.value_of("AUTH TOKEN");
src/main.rs:62
src/main.rs:63     let mut server = Nickel::new();
               ...
src/main.rs:61:24: 61:31 error: `matches` does not live long enough
src/main.rs:61     let auth_token   = matches.value_of("AUTH TOKEN");
                                      ^~~~~~~
note: reference must be valid for the static lifetime...
src/main.rs:58:24: 72:2 note: ...but borrowed value is only valid for the block suffix following st
atement 0 at 58:23
src/main.rs:58         .get_matches();
src/main.rs:59
src/main.rs:60     let logfile_path = matches.value_of("LOG FILE").unwrap();
src/main.rs:61     let auth_token   = matches.value_of("AUTH TOKEN");
src/main.rs:62
src/main.rs:63     let mut server = Nickel::new();
               ...
error: aborting due to 2 previous errors
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

I don't understand what is wrong – this is essentially the same code as from the example. I tried commenting out a bunch of code besides what is essentially this:

fn main() {
    let matches = App::new("simple-log").version("v0.0.1")
        .arg(Arg::with_name("LOG FILE")
             .short("l")
             .long("logfile")
             .required(true)
             .takes_value(true))
        .arg(Arg::with_name("AUTH TOKEN")
             .short("t")
             .long("token")
             .takes_value(true))
        .get_matches();

    let logfile_path = matches.value_of("LOG FILE").unwrap();
    let auth_token   = matches.value_of("AUTH TOKEN");
}

… and now it compiles. There are lots of warnings, but that's fine.

None of the error messages above refer to any lines that are commented out. Now that I know that the error message do not refer to what is causing the problem, I know to look elsewhere.

The first thing I do is remove the references to those two variables. The code becomes this:

fn main() {
    let matches = App::new("simple-log").version("v0.0.1")
        .arg(Arg::with_name("LOG FILE")
             .short("l")
             .long("logfile")
             .required(true)
             .takes_value(true))
        .arg(Arg::with_name("AUTH TOKEN")
             .short("t")
             .long("token")
             .takes_value(true))
        .get_matches();

    let logfile_path = matches.value_of("LOG FILE").unwrap();
    let auth_token   = matches.value_of("AUTH TOKEN");


    let mut server = Nickel::new();
    server.utilize(router! {
        get "**" => |_req, _res| {
            do_log_time("", Some(""))
        }
    });

    server.listen("127.0.0.1:6767");
}

This compiles and runs correctly. Now that I know this is the problem, I suspect that this is because the get request is routing to the get ** closure, and importing these variables into a closure would clearly impact their lifetimes.

I talked with my friend Carol Nichols about the problem, and she was able to suggest something that got me one step closer: convert logfile_path and auth_token to String types.

What I believe is going on here is that logfile_path and auth_token are both borrowed str types from somewhere inside the matches data structure, which goes out of scope… some time. At the end of main? Since main should still be running while the closure exists, it seems like matches should still exist.

Alternatively, it might be that closures just don't work with borrows. This seems unlikely to me. It seems more likely that the compiler can't prove that matches will still exist while closure could still be invoked. Although this still doesn't make sense, since the closure is passed into server, which would go out of scope at the same time as matches!

But anyway, changing this code:

// ...
let logfile_path = matches.value_of("LOG FILE").unwrap();
let auth_token   = matches.value_of("AUTH TOKEN");

let mut server = Nickel::new();
server.utilize(router! {
    get "**" => |_req, _res| {
        do_log_time(logfile_path, auth_token)
    }
});
// ...

into this:

// ...
let logfile_path = matches.value_of("LOG FILE").unwrap().to_string();
let auth_token = match matches.value_of("AUTH TOKEN") {
    Some(str) => Some(str.to_string()),
    None => None
};

let mut server = Nickel::new();
server.utilize(router! {
    get "**" => |_req, _res| {
        do_log_time(logfile_path, auth_token)
    }
});

server.listen("127.0.0.1:6767");
// ...

… fixed the problem. I also had to change the various functions that take &str types to take String types.

Of course, this reveals a new problem:

$ cargo build
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:69:25: 69:37 error: cannot move out of captured outer variable in an `Fn` closure
src/main.rs:69             do_log_time(logfile_path, auth_token)
                                       ^~~~~~~~~~~~
<nickel macros>:1:1: 1:27 note: in expansion of as_block!
<nickel macros>:10:12: 10:42 note: expansion site
note: in expansion of closure expansion
<nickel macros>:9:6: 10:54 note: expansion site
<nickel macros>:1:1: 10:62 note: in expansion of _middleware_inner!
<nickel macros>:4:1: 4:60 note: expansion site
<nickel macros>:1:1: 7:46 note: in expansion of middleware!
<nickel macros>:11:32: 11:78 note: expansion site
<nickel macros>:1:1: 21:78 note: in expansion of _router_inner!
<nickel macros>:4:1: 4:43 note: expansion site
<nickel macros>:1:1: 4:47 note: in expansion of router!
src/main.rs:67:20: 71:6 note: expansion site
src/main.rs:69:39: 69:49 error: cannot move out of captured outer variable in an `Fn` closure
src/main.rs:69             do_log_time(logfile_path, auth_token)
                                                     ^~~~~~~~~~
<nickel macros>:1:1: 1:27 note: in expansion of as_block!
<nickel macros>:10:12: 10:42 note: expansion site
note: in expansion of closure expansion
<nickel macros>:9:6: 10:54 note: expansion site
<nickel macros>:1:1: 10:62 note: in expansion of _middleware_inner!
<nickel macros>:4:1: 4:60 note: expansion site
<nickel macros>:1:1: 7:46 note: in expansion of middleware!
<nickel macros>:11:32: 11:78 note: expansion site
<nickel macros>:1:1: 21:78 note: in expansion of _router_inner!
<nickel macros>:4:1: 4:43 note: expansion site
<nickel macros>:1:1: 4:47 note: in expansion of router!
src/main.rs:67:20: 71:6 note: expansion site
error: aborting due to 2 previous errors
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

At first glance, this error doesn't make any sense to me:

src/main.rs:69:25: 69:37 error: cannot move out of captured outer variable in an `Fn` closure
src/main.rs:69             do_log_time(logfile_path, auth_token)

What does it mean to "move out of" a captured variable? I don't remember anything that used language like moving in to or out of variables, and besides, that sentence doesn't make any sense to me.

The error also says some other weird stuff; what does a Fn closure have to do with any of this?

I searched the Internet a while for this error message, and found some results. However, none of them seemed like they applied to me. So, back to playing around

7 More Debugging

First, I tried compiling with the --verbose flag just to see if was helpful, but it did not print any additional debugging information about the error, only about the general command.

I remembered seeing a section specific to closures in the the Rust book, so I decided to look at that. From it, my guess is that I need to do a "move" closure. But, when I try it:

server.utilize(router! {
    get "**" => move |_req, _res| {
        do_log_time(logfile_path, auth_token)
    }
});

… I get a new error message:

$ cargo run -- -l whodat
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:66:21: 66:25 error: no rules expected the token `move`
src/main.rs:66         get "**" => move |_req, _res| {
                                   ^~~~
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

This confused me, so I decided to just try to move it outside:

foo = move |_req, _res| {
    do_log_time(logfile_path, auth_token)
};

server.utilize(router! {
    get "**" => foo
});

$ cargo run -- -l whodat
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:70:21: 70:24 error: no rules expected the token `foo`
src/main.rs:70         get "**" => foo
                                   ^~~
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

This is the same error message.

At this point, I notice that the language of the error message sounds suspiciously like the wording used around Scheme pattern matching macro systems, and I remember the router! macro being used here. Some macro weirdness! I know how to solve this, because I had to deal with it before.

$ rustc src/main.rs --pretty=expanded -Z unstable-options
src/main.rs:5:14: 5:34 error: can't find crate for `nickel`
src/main.rs:5 #[macro_use] extern crate nickel;

So, I guess I need to pass this argument to cargo? Searching cargo docs doesnt seem to show anything about passing rustc arguments.

Searching the Internet, I found some GitHub issues that indicate sending arbitrary arguments is not supported, besides creating a custom cargo command. Creating a custom cargo command sounds like an awful diversion from the problem I am trying to solve right now, so I don't want to go down that route.

Suddenly, a wild idea appears: when using cargo run --verbose, I saw this rustc command in its output:

# ...
Caused by:
  Process didn't exit successfully: `rustc src/main.rs --crate-name simple_log --crate-type bin -g -
-out-dir /Users/joel/Projects/simple-log/target/debug --emit=dep-info,link -L dependency=/Users/joel
/Projects/simple-log/target/debug -L dependency=/Users/joel/Projects/simple-log/target/debug/deps --
extern nickel=/Users/joel/Projects/simple-log/target/debug/deps/libnickel-0a4cb77ee6c08a8b.rlib --ex
tern chrono=/Users/joel/Projects/simple-log/target/debug/deps/libchrono-a9b06d7e3a59ae0d.rlib --exte
rn clap=/Users/joel/Projects/simple-log/target/debug/deps/libclap-01156bdabdb6927f.rlib -L native=/U
sers/joel/Projects/simple-log/target/debug/build/openssl-sys-9c1a0f13b3d0a12d/out -L native=/Users/j
oel/Projects/simple-log/target/debug/build/time-30c208bd835b525d/out` (exit code: 101)
# ...

… which makes me wonder: Could I modify this to make it compile and output the macro-expanded code? Trying it:

$ rustc src/main.rs --crate-name simple_log --crate-type bin -g --out-dir /Users/joel/Projects/simple-log/target/debug --emit=dep-info,link -L dependency=/Users/joel/Projects/simple-log/target/debug -L
dependency=/Users/joel/Projects/simple-log/target/debug/deps --extern nickel=/Users/joel/Projects/simple-log/target/debug/deps/libnickel-0a4cb77ee6c08a8b.rlib --extern chrono=/Users/joel/Projects/simple
-log/target/debug/deps/libchrono-a9b06d7e3a59ae0d.rlib --extern clap=/Users/joel/Projects/simple-log/target/debug/deps/libclap-01156bdabdb6927f.rlib -L native=/Users/joel/Projects/simple-log/target/debu
g/build/openssl-sys-9c1a0f13b3d0a12d/out -L native=/Users/joel/Projects/simple-log/target/debug/build/time-30c208bd835b525d/out --pretty=expanded -Z unstable-options > macro-expanded.rs
$ cat macro-expanded.rs
#![feature(no_std)]
#![no_std]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std as std;
use std::io::prelude::*;
...

It worked! It is inelegant, but at least I was able to figure it out. It is also clearer to me how the cargo interfaces with rustc.

The relevant portion of the output is this:

server.utilize({
                   use nickel::HttpRouter;
                   let mut router = ::nickel::Router::new();
                   {
                       router.get("**",
                                  {
                                      use nickel::{MiddlewareResult,
                                                   Responder, Response,
                                                   Request};
                                      #[inline(always)]
                                      fn restrict<'a,
                                                  R: Responder>(r: R,
                                                                res:
                                                                    Response<'a>)
                                       -> MiddlewareResult<'a> {
                                          res.send(r)
                                      }
                                      #[inline(always)]
                                      fn restrict_closure<F>(f: F) -> F
                                       where F: for<'r, 'b,
                                       'a>Fn(&'r mut Request<'b, 'a, 'b>,
                                             Response<'a>) ->
                                       MiddlewareResult<'a> + Send +
                                       Sync {
                                          f
                                      }
                                      restrict_closure(move |_req, _res| {
                                                       restrict({
                                                                    do_log_time(logfile_path,
                                                                                auth_token)
                                                                }, _res)
                                                   })
                                  });
                       router
                   }
               });

Ok, so that's a lot to look at. Let us unpack it a little bit.

There are two functions, restrict and restrict_closure, that immediately surprise me. I think they exist to provide better type/error messaging about these request handling closures.

However, what is even more interesting is:

restrict_closure(move |_req, _res| { ... })

… which tells me that macro is specify the closure as a move closure already. Well, there goes that theory.

8 Regrouping

Lets regroup and try to restate the problem. At this point, I have a main that looks like this:

fn main() {
    let matches = App::new("simple-log").version("v0.0.1")
        .arg(Arg::with_name("LOG FILE")
             .short("l")
             .long("logfile")
             .required(true)
             .takes_value(true))
        .arg(Arg::with_name("AUTH TOKEN")
             .short("t")
             .long("token")
             .takes_value(true))
        .get_matches();

    let logfile_path = matches.value_of("LOG FILE").unwrap().to_string();
    let auth_token = match matches.value_of("AUTH TOKEN") {
        Some(str) => Some(str.to_string()),
        None => None
    };

    let mut server = Nickel::new();
    server.utilize(router! {
        get "**" => |_req, _res| {
            do_log_time(logfile_path, auth_token)
        }
    });

    server.listen("127.0.0.1:6767");
}

Compiling gives me this:

$ cargo build
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:69:25: 69:37 error: cannot move out of captured outer variable in an `Fn` closure
src/main.rs:69             do_log_time(logfile_path, auth_token)
                                       ^~~~~~~~~~~~
<nickel macros>:1:1: 1:27 note: in expansion of as_block!
<nickel macros>:10:12: 10:42 note: expansion site
note: in expansion of closure expansion
<nickel macros>:9:6: 10:54 note: expansion site
<nickel macros>:1:1: 10:62 note: in expansion of _middleware_inner!
<nickel macros>:4:1: 4:60 note: expansion site
<nickel macros>:1:1: 7:46 note: in expansion of middleware!
<nickel macros>:11:32: 11:78 note: expansion site
<nickel macros>:1:1: 21:78 note: in expansion of _router_inner!
<nickel macros>:4:1: 4:43 note: expansion site
<nickel macros>:1:1: 4:47 note: in expansion of router!
src/main.rs:67:20: 71:6 note: expansion site
src/main.rs:69:39: 69:49 error: cannot move out of captured outer variable in an `Fn` closure
src/main.rs:69             do_log_time(logfile_path, auth_token)
                                                     ^~~~~~~~~~
<nickel macros>:1:1: 1:27 note: in expansion of as_block!
<nickel macros>:10:12: 10:42 note: expansion site
note: in expansion of closure expansion
<nickel macros>:9:6: 10:54 note: expansion site
<nickel macros>:1:1: 10:62 note: in expansion of _middleware_inner!
<nickel macros>:4:1: 4:60 note: expansion site
<nickel macros>:1:1: 7:46 note: in expansion of middleware!
<nickel macros>:11:32: 11:78 note: expansion site
<nickel macros>:1:1: 21:78 note: in expansion of _router_inner!
<nickel macros>:4:1: 4:43 note: expansion site
<nickel macros>:1:1: 4:47 note: in expansion of router!
src/main.rs:67:20: 71:6 note: expansion site
error: aborting due to 2 previous errors
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

I asked about it on IRC, but I got no replies. Realistically, I should have probably tried to ask on IRC during a time that I had more patience, but it is what it is.

I submitted an issue on the nickel.rs project, thinking that this was an issue with the macro. This was the last idea I had – I knew how likely it was that I was wrong, but I saw no other way forward and I didn't want to give up.

And thus the issue at https://github.com/nickel-org/nickel.rs/issues/241 was born. Ryman quickly saw my mistake and was kind enough to help me through it. Sure enough, he was right – if you're reading this Ryman, I owe you one.

The problem occurred in the following specific closure. Let us examine it to see what we can see:

get "**" => |_req, _res| {
    do_log_time(logfile_path, auth_token)
}

If you notice, here, the call to do_log_time is transferring ownership of logfile_path and auth_token to that invocation of that function. This is where the problem is.

To my untrained eye, this looks "normal", the most natural form of the code. There is an important caveat that I missed: in its current form, this lambda cannot be called more than once. On the first time it is called, ownership of logfile_path and auth_token are transferred to the invocation of do_log_time. Here's the thing: if this function is called again, it couldn't transfer ownership to do_log_time, as it no longer owns these two variables.

Thus, we get the error message:

src/main.rs:69:39: 69:49 error: cannot move out of captured outer variable in an `Fn` closure

I still don't think it makes any sense but now I understand at least that it deals with moving ownership "out" from a closure.

Anyway, the simplest way to fix this problem is to do:

let mut server = Nickel::new();
server.utilize(router! {
    get "**" => |_req, _res| {
        do_log_time(logfile_path.clone(), auth_token.clone())
    }
});

Now, upon each invocation, logfile_path and auth_token are still owned, but clones are created and ownership of the clones is transferred.

However, I'd like to point out that I still believe this is a sub-optimal solution. Since passing ownership is not referentially transparent by definition, I'm now leaning towards favoring the use of references whenever possible.

Would rust have been better if it used bare symbols to represent borrowed references, but some other symbol for owned, say *? I don't know, but is an interesting question.

9 Refactoring

I'm going to try a quick refactor to see if I can make things use references. This is going to be interesting, because I might have some unforeseen problems arise – we'll see!

I've been reading the Martin Fowler Refactoring book, and this has renewed my appreciation for doing things in small steps at a time. First, I want to change just one ownership transfer to a borrow; lets start with logfile_path. Starting with this:

fn do_log_time(logfile_path: String, auth_token: Option<String>) -> String {
    match log_time(logfile_path) {
        Ok(entry) => format!("Entry Logged: {}", entry),
        Err(e) => format!("Error: {}", e)
    }
}

// ...

fn main() {
    // ...
    server.utilize(router! {
        get "**" => |_req, _res| {
            do_log_time(logfile_path.clone(), auth_token.clone())
        }
    });
   // ...
}

I end up with this:

fn do_log_time(logfile_path: &String, auth_token: Option<String>) -> String {
    match log_time(logfile_path.clone()) {
        Ok(entry) => format!("Entry Logged: {}", entry),
        Err(e) => format!("Error: {}", e)
    }
}

// ...

fn main() {
    // ...
    server.utilize(router! {
        get "**" => |_req, _res| {
            do_log_time(&logfile_path, auth_token.clone())
        }
    });
   // ...
}

This refactoring might be called something like: replace ownership with borrow and clone. If I own something, and I want to change this to a borrow, but I currently transfer ownership somewhere else, I must create my own copy internally first. This allows me to change my ownership to a borrow, and yet still transfer ownership when I must. Of course, this involves cloning the thing I borrowed, which duplicates memory and has performance costs, but it allows me to change this line of code safely. I can then keep replacing ownership with borrows without breaking anything.

Applying this a few more times gives me this code:

use std::io::prelude::*;
use std::fs::OpenOptions;
use std::io;

#[macro_use] extern crate nickel;
use nickel::Nickel;

extern crate chrono;
use chrono::{DateTime,Local};

extern crate clap;
use clap::{App,Arg};

fn formatted_time_entry() -> String {
    let local: DateTime<Local> = Local::now();
    let formatted = local.format("%a, %b %d %Y %I:%M:%S %p\n").to_string();
    formatted
}

fn record_entry_in_log(filename: &String, bytes: &[u8]) -> io::Result<()> {
    let mut file = try!(OpenOptions::new().
                        append(true).
                        write(true).
                        create(true).
                        open(filename));
    try!(file.write_all(bytes));
    Ok(())
}

fn log_time(filename: &String) -> io::Result<String> {
    let entry = formatted_time_entry();
    {
        let bytes = entry.as_bytes();

        try!(record_entry_in_log(filename, &bytes));
    }
    Ok(entry)
}

fn do_log_time(logfile_path: &String, auth_token: &Option<String>) -> String {
    match log_time(logfile_path) {
        Ok(entry) => format!("Entry Logged: {}", entry),
        Err(e) => format!("Error: {}", e)
    }
}

fn main() {
    let matches = App::new("simple-log").version("v0.0.1")
        .arg(Arg::with_name("LOG FILE")
             .short("l")
             .long("logfile")
             .required(true)
             .takes_value(true))
        .arg(Arg::with_name("AUTH TOKEN")
             .short("t")
             .long("token")
             .takes_value(true))
        .get_matches();

    let logfile_path = matches.value_of("LOG FILE").unwrap().to_string();
    let auth_token = match matches.value_of("AUTH TOKEN") {
        Some(str) => Some(str.to_string()),
        None => None
    };

    let mut server = Nickel::new();
    server.utilize(router! {
        get "**" => |_req, _res| {
            do_log_time(&logfile_path, &auth_token)
        }
    });

    server.listen("127.0.0.1:6767");

}

I'm going to need to deal with auth_token soon, but for now this is a good place to stop.

10 Conclusions & Retrospective on Part 4

The application now parses options. However, it was tremendously difficult. I nearly ran out of options while trying solve my problems. I would have been really frustrated if the issue on nickel.rs wasn't resolved so helpfully.

Some lessons:

Transferring ownership is a tricky thing. I think a new guideline for me is to favor passing immutable borrows by default unless I must pass ownership for whatever reason.
Cargo really should have an option to pass arbitrary rustc arguments.
Some of the Rust error messages are still not very good.
Even if the error messages were poor, Rust was still right – transferring ownership inside my closure was an error, since the function is called many times, once per web request. A lesson here for me is: if I don't understand an error message, it would be a good idea to think through the code, specifically looking what might be hard for Rust to prove to be safe.

This experience also reinforces my frustration with compiled, strong-typed programming languages. Sometimes, you really need to examine things in vivo in order to appreciate what is going on. In this example, it was hard to create a minimal reproducible that illustrated the problem.

When error messages don't give you the information you need, you're next best option is to start searching the Internet for information related to the error message. This doesn't really give you the ability to investigate, understand, and solve the problem yourself.

I think this could be alleviated by adding some ability to interrogate the state of the compiler at different times, to find more information about the problem. Something like opening an interactive prompt on compile errors would be really great, but even annotating the code to request detailed information from the compiler would be extremely useful.

—

I wrote this post over the course of about a month, mostly because I was so busy dealing with house buying stuff. At times, I was extremely frustrated with some of this. I expected integrating option parsing to be the easiest of tasks!

However, realizing that Rust caught my bug really relieving. Even if the error message wasn't as good as I had hoped, I liked that this would have been a legitimate segmentation fault that I was saved from.

I hope that as Rust matures, the error messages get better. If they do, I think all my concerns will disappear.

—

Series: A Simple Web App in Rust

A Simple Web App in Rust, Part 3 -- Integration

Sat, 04 Jul 2015 00:00:00 -0400

1. Previously
- 1.1. Review
2. Combining the Code: Fisticuffing with the Type System
3. Fin

1 Previously

This is the third part in a series on writing a very simple web application in Rust.

So far, we have the the pieces for an MVP in separate rust files. Here, we want to put them together into a single app.

1.1 Review

We have the following two pieces to put together: the file writing/logging code, and the serving code. Lets review each of them.

First, the logging code:

extern crate chrono;

use std::io::prelude::*;
use std::fs::{File,OpenOptions};
use std::io;
use chrono::{DateTime,Local};


fn formatted_time_entry() -> String {
    let local: DateTime<Local> = Local::now();
    let formatted = local.format("%a, %b %d %Y %I:%M:%S %p\n").to_string();
    formatted
}

fn record_entry_in_log(filename: &str, bytes: &[u8]) -> io::Result<()> {
    let mut file = try!(OpenOptions::new().
                        append(true).
                        write(true).
                        create(true).
                        open(filename));
    try!(file.write_all(bytes));
    Ok(())
}

fn log_time(filename: &'static str) -> io::Result<()> {
    let entry = formatted_time_entry();
    let bytes = entry.as_bytes();

    try!(record_entry_in_log(filename, &bytes));
    Ok(())
}

fn main() {
    match log_time("log.txt") {
        Ok(..) => println!("File created!"),
        Err(e) => println!("Error: {}", e)
    }
}

Now, the serving code:

#[macro_use] extern crate nickel;

use nickel::Nickel;

fn say_hello() -> &'static str {
    "Hello dear world!"
}

fn main() {
    let mut server = Nickel::new();

    server.utilize(router! {
        get "**" => |_req, _res| {
            say_hello()
        }
    });

    server.listen("127.0.0.1:6767");
}

2 Combining the Code: Fisticuffing with the Type System

So, I want to combine these two programs. First, I'll put them both into the same file (and change the name of one of the main functions, of course) to see if they all compile together.

#[macro_use] extern crate nickel;
extern crate chrono;

use std::io::prelude::*;
use std::fs::{File,OpenOptions};
use std::io;
use chrono::{DateTime,Local};

use nickel::Nickel;

fn formatted_time_entry() -> String {
    let local: DateTime<Local> = Local::now();
    let formatted = local.format("%a, %b %d %Y %I:%M:%S %p\n").to_string();
    formatted
}

fn record_entry_in_log(filename: &str, bytes: &[u8]) -> io::Result<()> {
    let mut file = try!(OpenOptions::new().
                        append(true).
                        write(true).
                        create(true).
                        open(filename));
    try!(file.write_all(bytes));
    Ok(())
}

fn log_time(filename: &'static str) -> io::Result<()> {
    let entry = formatted_time_entry();
    let bytes = entry.as_bytes();

    try!(record_entry_in_log(filename, &bytes));
    Ok(())
}

fn main2() {
    match log_time("log.txt") {
        Ok(..) => println!("File created!"),
        Err(e) => println!("Error: {}", e)
    }
}


fn say_hello() -> &'static str {
    "Hello dear world!"
}

fn main() {
    let mut server = Nickel::new();

    server.utilize(router! {
        get "**" => |_req, _res| {
            say_hello()
        }
    });

    server.listen("127.0.0.1:6767");
}

Compiling & Running:

$ cargo run
src/main.rs:5:15: 5:19 warning: unused import, #[warn(unused_imports)] on by default
src/main.rs:5 use std::fs::{File,OpenOptions};
                            ^~~~
src/main.rs:11:1: 15:2 warning: function is never used: `formatted_time_entry`, #[warn(dead_code)] o
n by default
src/main.rs:11 fn formatted_time_entry() -> String {
src/main.rs:12     let local: DateTime<Local> = Local::now();
src/main.rs:13     let formatted = local.format("%a, %b %d %Y %I:%M:%S %p\n").to_string();
src/main.rs:14     formatted
src/main.rs:15 }
src/main.rs:17:1: 25:2 warning: function is never used: `record_entry_in_log`, #[warn(dead_code)] on
 by default
src/main.rs:17 fn record_entry_in_log(filename: &str, bytes: &[u8]) -> io::Result<()> {
src/main.rs:18     let mut file = try!(OpenOptions::new().
src/main.rs:19                         append(true).
src/main.rs:20                         write(true).
src/main.rs:21                         create(true).
src/main.rs:22                         open(filename));
               ...
src/main.rs:27:1: 33:2 warning: function is never used: `log_time`, #[warn(dead_code)] on by default
src/main.rs:27 fn log_time(filename: &'static str) -> io::Result<()> {
src/main.rs:28     let entry = formatted_time_entry();
src/main.rs:29     let bytes = entry.as_bytes();
src/main.rs:30
src/main.rs:31     try!(record_entry_in_log(filename, &bytes));
src/main.rs:32     Ok(())
               ...
src/main.rs:35:1: 40:2 warning: function is never used: `main2`, #[warn(dead_code)] on by default
src/main.rs:35 fn main2() {
src/main.rs:36     match log_time("log.txt") {
src/main.rs:37         Ok(..) => println!("File created!"),
src/main.rs:38         Err(e) => println!("Error: {}", e)
src/main.rs:39     }
src/main.rs:40 }
     Running `target/debug/simple-log`
Listening on http://127.0.0.1:6767
Ctrl-C to shutdown server

Cool. I totally expected those dead-code warning messages, and visiting localhost:6767 in my browser still renders a "hello, world" page.

Here's an attempt to integrate them:

#[macro_use] extern crate nickel;
extern crate chrono;

use std::io::prelude::*;
use std::fs::{File,OpenOptions};
use std::io;
use chrono::{DateTime,Local};

use nickel::Nickel;

fn formatted_time_entry() -> String {
    let local: DateTime<Local> = Local::now();
    let formatted = local.format("%a, %b %d %Y %I:%M:%S %p\n").to_string();
    formatted
}

fn record_entry_in_log(filename: &str, bytes: &[u8]) -> io::Result<()> {
    let mut file = try!(OpenOptions::new().
                        append(true).
                        write(true).
                        create(true).
                        open(filename));
    try!(file.write_all(bytes));
    Ok(())
}

fn log_time(filename: &'static str) -> io::Result<()> {
    let entry = formatted_time_entry();
    let bytes = entry.as_bytes();

    try!(record_entry_in_log(filename, &bytes));
    Ok(())
}

fn do_log_time() -> &'static str {
    match log_time("log.txt") {
        Ok(..) => println!("File created!"),
        Err(e) => println!("Error: {}", e)
    }
}

fn main() {
    let mut server = Nickel::new();

    server.utilize(router! {
        get "**" => |_req, _res| {
            do_log_time()
        }
    });

    server.listen("127.0.0.1:6767");
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:37:19: 37:44 error: mismatched types:
 expected `&'static str`,
    found `()`
(expected &-ptr,
    found ()) [E0308]
src/main.rs:37         Ok(..) => println!("File created!"),
                                 ^~~~~~~~~~~~~~~~~~~~~~~~~
src/main.rs:38:19: 38:43 error: mismatched types:
 expected `&'static str`,
    found `()`
(expected &-ptr,
    found ()) [E0308]
src/main.rs:38         Err(e) => println!("Error: {}", e)
                                 ^~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 2 previous errors
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

The macro println! here is writing to standard out, but what I want is something that will be returning a string. Is there a sprintln!, or something equivalent?

Doing a quick search, it looks like the answer is format!:

#[macro_use] extern crate nickel;
extern crate chrono;

use std::io::prelude::*;
use std::fs::{File,OpenOptions};
use std::io;
use chrono::{DateTime,Local};

use nickel::Nickel;

fn formatted_time_entry() -> String {
    let local: DateTime<Local> = Local::now();
    let formatted = local.format("%a, %b %d %Y %I:%M:%S %p\n").to_string();
    formatted
}

fn record_entry_in_log(filename: &str, bytes: &[u8]) -> io::Result<()> {
    let mut file = try!(OpenOptions::new().
                        append(true).
                        write(true).
                        create(true).
                        open(filename));
    try!(file.write_all(bytes));
    Ok(())
}

fn log_time(filename: &'static str) -> io::Result<()> {
    let entry = formatted_time_entry();
    let bytes = entry.as_bytes();

    try!(record_entry_in_log(filename, &bytes));
    Ok(())
}

fn do_log_time() -> &'static str {
    match log_time("log.txt") {
        Ok(..) => format!("File created!"),
        Err(e) => format!("Error: {}", e)
    }
}

fn main() {
    let mut server = Nickel::new();

    server.utilize(router! {
        get "**" => |_req, _res| {
            do_log_time()
        }
    });

    server.listen("127.0.0.1:6767");
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:37:19: 37:43 error: mismatched types:
 expected `&'static str`,
    found `collections::string::String`
(expected &-ptr,
    found struct `collections::string::String`) [E0308]
src/main.rs:37         Ok(..) => format!("File created!"),
                                 ^~~~~~~~~~~~~~~~~~~~~~~~
src/main.rs:38:19: 38:42 error: mismatched types:
 expected `&'static str`,
    found `collections::string::String`
(expected &-ptr,
    found struct `collections::string::String`) [E0308]
src/main.rs:38         Err(e) => format!("Error: {}", e)
                                 ^~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 2 previous errors
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

So, I know there's a way to convert between a String and an &str… hmm. I recall that I can use an &.

fn do_log_time() -> &'static str {
    match log_time("log.txt") {
        Ok(..) => &format!("File created!"),
        Err(e) => &format!("Error: {}", e)
    }
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:37:20: 37:44 error: borrowed value does not live long enough
src/main.rs:37         Ok(..) => &format!("File created!"),
                                  ^~~~~~~~~~~~~~~~~~~~~~~~
note: reference must be valid for the static lifetime...
src/main.rs:37:19: 37:44 note: ...but borrowed value is only valid for the expression at 37:18
src/main.rs:37         Ok(..) => &format!("File created!"),
                                 ^~~~~~~~~~~~~~~~~~~~~~~~~
src/main.rs:38:20: 38:43 error: borrowed value does not live long enough
src/main.rs:38         Err(e) => &format!("Error: {}", e)
                                  ^~~~~~~~~~~~~~~~~~~~~~~
note: reference must be valid for the static lifetime...
src/main.rs:38:19: 38:43 note: ...but borrowed value is only valid for the expression at 38:18
src/main.rs:38         Err(e) => &format!("Error: {}", e)
                                 ^~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 2 previous errors
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

This thing again. I think I'm going to need a block here:

fn do_log_time() -> &'static str {
    match log_time("log.txt") {
        Ok(..) => {
            let fmt = format!("File created!");
            &fmt
        },
        Err(e) => {
            let fmt = format!("Error: {}", e);
            &fmt
        }
    }
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:39:14: 39:17 error: `fmt` does not live long enough
src/main.rs:39             &fmt
                            ^~~
note: reference must be valid for the static lifetime...
src/main.rs:38:48: 40:10 note: ...but borrowed value is only valid for the block suffix following s
tatement 0 at 38:47
src/main.rs:38             let fmt = format!("File created!");
src/main.rs:39             &fmt
src/main.rs:40         },
src/main.rs:43:14: 43:17 error: `fmt` does not live long enough
src/main.rs:43             &fmt
                            ^~~
note: reference must be valid for the static lifetime...
src/main.rs:42:47: 44:10 note: ...but borrowed value is only valid for the block suffix following s
tatement 0 at 42:46
src/main.rs:42             let fmt = format!("Error: {}", e);
src/main.rs:43             &fmt
src/main.rs:44         }
error: aborting due to 2 previous errors
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

That didn't work. I think the problem is that fmt only exists for that new block, but the return value is used outside of it. What if I promote fmt to the top of the function?

fn do_log_time() -> &'static str {
    let mut fmt = "".to_string();
    match log_time("log.txt") {
        Ok(..) => {
            fmt = format!("File created!");
            &fmt
        },
        Err(e) => {
            fmt = format!("Error: {}", e);
            &fmt
        }
    }

}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:40:14: 40:17 error: `fmt` does not live long enough
src/main.rs:40             &fmt
                            ^~~
note: reference must be valid for the static lifetime...
src/main.rs:36:34: 48:2 note: ...but borrowed value is only valid for the block suffix following st
atement 0 at 36:33
src/main.rs:36     let mut fmt = "".to_string();
src/main.rs:37     match log_time("log.txt") {
src/main.rs:38         Ok(..) => {
src/main.rs:39             fmt = format!("File created!");
src/main.rs:40             &fmt
src/main.rs:41         },
               ...
src/main.rs:44:14: 44:17 error: `fmt` does not live long enough
src/main.rs:44             &fmt
                            ^~~
note: reference must be valid for the static lifetime...
src/main.rs:36:34: 48:2 note: ...but borrowed value is only valid for the block suffix following st
atement 0 at 36:33
src/main.rs:36     let mut fmt = "".to_string();
src/main.rs:37     match log_time("log.txt") {
src/main.rs:38         Ok(..) => {
src/main.rs:39             fmt = format!("File created!");
src/main.rs:40             &fmt
src/main.rs:41         },
               ...
error: aborting due to 2 previous errors
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

I don't know how to fix this. I'm going to just set this down, for now, and come back to it later.

—

I've tried a few new things, and nothing works. I think I need to learn more of how this ownership/lifetime stuff works.

I just read a bit of the Rust book, and I notice this note:

We choose the String type for the name, rather than &str. Generally speaking, working with a type which owns its data is easier than working with one that uses references.

Because I'm in "do" mode and not "learn" mode, I want to try using String to see if that works.

Now:

fn do_log_time() -> String {
    match log_time("log.txt") {
        Ok(..) => format!("File created!"),
        Err(e) => format!("Error: {}", e)
    }
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
     Running `target/debug/simple-log`
Listening on http://127.0.0.1:6767
Ctrl-C to shutdown server

It worked. Visiting the page in a browser shows "File created!", and it also wrote an entry to the log file.

I'm not really surprised that this works – I kinda figured the solution would be to return a String instead of an &str, but I wanted to take it as a challenge to figure out.

Now that I think about it, this makes sense. I'm trying to return a borrowed reference, but I also own it, so returning it wouldn't make any sense. How would I return an &str that I created in my own function? I haven't seen anything using a plain, not-borrowed "str" anywhere.

I this absence of not-borrowed ~&str~s has to do with it representing being a plain c string pointer. This must have some complications that I'm not aware of, and for it to play nicely with Rust it must interface with rust the normal Rust rules sharing ownership must apply.

If some other part of the program has knowledge of an array of bytes, and provides me with a reference to that array, what does that mean? Are &str types basically just so that C strings can be referenced without some additional metadata associated with them?

The Rust book says &str -> String has some cost. I wonder if this always true, or only for static program strings. Would a heap-allocated &str require copying for a String? Now that I think about it, I bet the answer is yes; if you want to convert a borrowed value into something that is owned, the only reasonable solution would be to copy it.

Anyway, I think I just want to move on. I think the answer is that what I was trying to do just didn't make sense, and Rust correctly stopped me. I do wish I understood why every str is borrowed, though.

I'm going to try to return the logged time string from log_time and have that displayed to the user. My first attempt:

fn log_time(filename: &'static str) -> io::Result<String> {
    let entry = formatted_time_entry();
    let bytes = entry.as_bytes();

    try!(record_entry_in_log(filename, &bytes));
    Ok(entry)
}

fn do_log_time() -> String {
    match log_time("log.txt") {
        Ok(entry) => format!("Entry Logged: {}", entry),
        Err(e) => format!("Error: {}", e)
    }
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:32:8: 32:13 error: cannot move out of `entry` because it is borrowed
src/main.rs:32     Ok(entry)
                      ^~~~~
src/main.rs:29:17: 29:22 note: borrow of `entry` occurs here
src/main.rs:29     let bytes = entry.as_bytes();
                               ^~~~~
error: aborting due to previous error
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

Hmm. So I guess that makes sense… bytes "borrows" the contents of entry. And, since this value is still borrowed by the time OK(entry) is called, this causes the error.

This works:

fn log_time(filename: &'static str) -> io::Result<String> {
    let entry = formatted_time_entry();
    {
        let bytes = entry.as_bytes();

        try!(record_entry_in_log(filename, &bytes));
    }
    Ok(entry)
}

$ cargo run &
[1] 66858
$      Running `target/debug/simple-log`
Listening on http://127.0.0.1:6767
Ctrl-C to shutdown server

$ curl localhost:6767
Entry Logged: Tue, Jun 23 2015 12:34:19 AM

This isn't the first time I've used the "stick a new block here" feature, but it does seem to work for this, and it seems like a reasonably elegant way to handle this. My first thought though was that I needed to call another function to somehow "convert" bytes back into a String, but then I realized that this didn't actually make sense, and I needed to "deallocate" the borrow, somehow.

I don't understand what "move out of `entry`" means in that error message though. I'm thinking that you can't transfer ownership of a value as long as there is a borrowed reference to it, too. But maybe that isn't actually true. Is sending it to Ok() changing it? I'm pretty confused by this, and the Rust book doesn't seem to address this specific issue, but I think this must be it – ownership can't be changed while a borrow exists. I think.

Its nice to see that as I've been browsing through the Rust book section on borrowing, using a block is the cited solution to this problem.

3 Fin

Integrating this was much harder than I expected. Borrowing/ownership got me a few times here, so I'm going to cut it at this point, since this has gotten pretty long.

Fortunately, I think I am slowly understanding how Rust works, and especially its borrowing functionality. This gives me hope for the future.

—

Series: A Simple Web App in Rust

Rust, the Language for Growth

Sun, 28 Jun 2015 00:00:00 -0400

The most important feature that attracts me to Rust is its focus on allowing the language to grow.

If Rust was going to remain static as it currently exists, I would probably have avoided it and chosen a different language to spend my time with, such as OCaml, Haskell, or Racket.

My two main concerns regarding code, and what influences the things I study, are:

How fast will I be able to go from idea to implementation?
How maintainable will the code be? Will I be able to make changes easily?

However, Rust brings me the following benefits:

Control of the hardware. I learned C as a student ages ago by reading K&R, and I know that for me to write production-quality C would require lots of ramp up time.
Speed. Even if my naive code isn't as fast as it could be, I feel reasonably sure that I can make whatever speed improvements I need without making the code unreasonably eldritch.

These sets of benefits don't intersect. So, why am I interested in Rust?

I see Rust as a starting point, a point from which other, higher level abstractions can be added. I have heard numerous times that features like garbage collection will be added after the fact, and that this is can be implemented as user-land libraries. Indeed, much of what would normally be in the standard library is being put into crates, allowing libraries to grow independent of Rust itself.

Racket, in contrast, is an amazing system for exploring and implementing new ideas in syntax, semantics, and abstraction. However, its runtime and base system mean that it is suitable for a relatively select domain of problems. These domains have large, established language communities (Ruby, Python) that are losing mind share because of these limitations, not because of a lack of expressiveness in those languages.

Because of these considerations, Rust is a good base language that can grow into the future. Its focus on not making trade-offs that preclude certain programming domains means that we can use it to starting building better systems, be they applications, operating systems, or new programming languages with a restricted domain of applicability.

Dealing With the Rust Shift in Perspective

Sat, 20 Jun 2015 00:00:00 -0400

There is a famous quote by Alan Kay:

"Perspective is worth 80 IQ points."

I have seen this happen over and over again. A change in perspective becomes popular, and the industry begins to adopt it.

I have witnessed the following shifts:

The shift from object-oriented to functional programming. We may be seeing another shift towards relational/logic programming, but that is still a long way off.
Reactive programming is becoming more popular. This may be seen in functional reactive programming and evented programming.
Memory management: Should memory allocation/deallocation be managed by the programmer? By a run-time analyzer that determines when memory is safe to be reclaimed? Or can memory usage be understood at compile-time, and managed safely?

This last point is what Rust specifically is addressing. By making memory usage something that is statically analyzable, an entire class of memory issues disappear.

You can always tell when a perspective shift is happening. It requires you to change how you think about problems, often in a way that is uncomfortable and frustrating. Tasks that used to be easy may now require a lot of effort, at least until you learn how to think in a new way. Also, the story of people who learn this new way of thinking is always the same: "It was hard for a while, but eventually I got it, and now it comes naturally!"

Paul Graham mentions in one of his essays that a programmer who doesn't understand how to think with a certain feature also won't see its value, and will think it isn't useful. I think this is quite true. I once could not understand the value of anonymous functions and closures, but now I can't program without them.

The key is to push through this hard time. I think reading the experiences of others who have already worked through the pain may be enough motivation to get you through.

Ultimately, I don't know if I will like dealing with memory in the Rust way. It may be that I don't. But I do know that I can't judge it properly until I've come through to the other side and gained the understanding of how to use it well. I bet that I will want to keep using garbage collection, but Rust will be my choice when this GC isn't feasible or possible.

A Simple Web App in Rust, Part 2b

Sun, 07 Jun 2015 00:00:00 -0400

1. The Series
2. Using Chrono
3. Writing the Date/Time to a File
4. Building a File Logger
- 4.1. Misunderstanding u8
- 4.2. Filling in Missing Pieces
5. Conclusion & Next Steps

1 The Series

This is a post in a series of me writing down my experience as I try to build a simple web app in Rust.

So far, we have:

The last part was especially harrowing. This piece will be to investigate date/time formatting in Rust, with a focus on writing visiting time in a nice format.

2 Using Chrono

So, searching for "date" on crates.io shows one prominent result, namely the crate "chrono". This looks very popular, and was updated very recently, so it looks like a good candidate. A look through the README seems to show that it has decent date/time pretty printing functionality.

The first thing would be to add the Chrono requirement line to Cargo.toml, but first let's move the old main.rs out of the way so that there is a new place to experiment:

$ ls
Cargo.lock Cargo.toml log.txt    src        target
$ cd src/
$ ls
main.rs     web_main.rs
$ git mv main.rs main_file_writing.rs
$ touch main.rs
$ git add main.rs
$ git status
On branch master
Your branch is up-to-date with 'origin/master'.
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

        modified:   main.rs
        copied:     main.rs -> main_file_writing.rs

Untracked files:
  (use "git add <file>..." to include in what will be committed)

        ../log.txt

$ git commit -m 'move file writing out of the way for working with dates'
[master 4cd2b0e] move file writing out of the way for working with dates
 2 files changed, 16 deletions(-)
 rewrite src/main.rs (100%)
 copy src/{main.rs => main_file_writing.rs} (100%)

Adding the dependency on Chrono to Cargo.toml:

[package]
name = "simple-log"
version = "0.1.0"
authors = ["Joel McCracken <mccracken.joel@gmail.com>"]

[dependencies]

chrono = "0.2"

[dependencies.nickel]

git = "https://github.com/nickel-org/nickel.rs.git"

The readme says this next:

And put this in your crate root:

    extern crate chrono;

I don't know what this means, but I'm just going to try to put it on top of main.rs because it looks like Rust code:

extern crate chrono;

fn main() { }

compiling:

$ cargo run
    Updating registry `https://github.com/rust-lang/crates.io-index`
 Downloading num v0.1.25
 Downloading rand v0.3.8
 Downloading chrono v0.2.14
   Compiling rand v0.3.8
   Compiling num v0.1.25
   Compiling chrono v0.2.14
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
     Running `/Users/joel/Projects/simple-log/target/debug/simple-log`

So, it looks like it downloaded Chrono, compiled successfully, and exited. Rad. I think the next step would be to try to use it. Based upon the first example listed, I have this:

extern crate chrono;
use chrono::*;

fn main() {
    let local: DateTime<Local> = Local::now();
    println!('{}', local);
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
main.rs:6:14: 6:16 error: unterminated character constant: '{
main.rs:6     println!('{}', local);
                       ^~
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

…? After I look at this for a second, I think its telling me that I need to use double quotes, not single quotes. which makes some sense, since single quotes are used in lifetime specifications.

After switching from single to double quotes:

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
     Running `/Users/joel/Projects/simple-log/target/debug/simple-log`
2015-06-05 16:54:47.483088 -04:00

… whoa. That was easy. It looks like println! has some kind of interface for whatever is being printed and can print many different things.

There is some irony here. So far, I was able to generate a simple hello world web application and print a well-formatted date and time with really very little effort, but writing to a file cost me dearly in time. I'm not sure what the lesson is, here. I think it is clear that the rust community has gone through great effort to make their packages nice to work with, even if the language is still hard to use (for me).

3 Writing the Date/Time to a File

I think the next sensible task would be to actually write this string to a file, and for this, I want to look at what I ended up with in the last entry:

$ cat main_file_writing.rs
use std::io::prelude::*;
use std::fs::File;
use std::io;

fn log_something(filename: &'static str, string: &'static [u8; 12]) -> io::Result<()> {
    let mut f = try!(File::create(filename));
    try!(f.write_all(string));
    Ok(())
}

fn main() {
    match log_something("log.txt", b"ITS ALIVE!!!") {
        Ok(..) => println!("File created!"),
        Err(..) => println!("Error: could not create file.")
    }
}

I'll just do a real quick merge of the above example with this one:

extern crate chrono;

use std::io::prelude::*;
use std::fs::File;
use std::io;
use chrono::*;

fn log_something(filename: &'static str, string: &'static [u8; 12]) -> io::Result<()> {
    let mut f = try!(File::create(filename));
    try!(f.write_all(string));
    Ok(())
}

fn main() {
    let local: DateTime<Local> = Local::now();
    println!('{}', local);
    match log_something("log.txt", b"ITS ALIVE!!!") {
        Ok(..) => println!("File created!"),
        Err(..) => println!("Error: could not create file.")
    }
}

compiling:

$ ls
Cargo.lock      Cargo.toml      log.txt         src             target
$ pwd
/Users/joel/Projects/simple-log
$ ls
Cargo.lock      Cargo.toml      log.txt         src             target
$ rm log.txt
$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
     Running `target/debug/simple-log`
2015-06-05 17:08:57.814176 -04:00
File created!
$ cat log.txt
ITS ALIVE!!!$

That all worked! It feels really good to go from struggling with a language, to being able to put things together with much less frustration.

4 Building a File Logger

We're getting closer to writing a real, bona fide piece of the final system. It hits me that I might like to write some tests for this code, but I'll add those in later.

Here's what this function should do:

Given a file name,
Create it first if doesn't exist, and open the file.
Create a time/date string,
Write that string to the file, and close the file.

4.1 Misunderstanding `u8`

My first attempt:

extern crate chrono;

use std::io::prelude::*;
use std::fs::File;
use std::io;
use chrono::*;

fn log_time(filename: &'static str) -> io::Result<()> {

    let local: DateTime<Local> = Local::now();
    let time_str = local.format("%Y").to_string();
    let mut f = try!(File::create(filename));
    try!(f.write_all(time_str));
    Ok(())
}

fn main() {
    match log_time("log.txt") {
        Ok(..) => println!("File created!"),
        Err(..) => println!("Error: could not create file.")
    }
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:13:22: 13:30 error: mismatched types:
 expected `&[u8]`,
    found `collections::string::String`
(expected &-ptr,
    found struct `collections::string::String`) [E0308]
src/main.rs:13     try!(f.write_all(time_str));
                                    ^~~~~~~~
<std macros>:1:1: 6:48 note: in expansion of try!
src/main.rs:13:5: 13:33 note: expansion site
error: aborting due to previous error
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

Ugh. So, I know that there are many types of strings in Rust¹, and it looks like I need a different one, here. Thing is, I don't know how to do this, so I'll have to do some searching.

I remember seeing a section in the Rust book specifically about strings. Looking into it, it says that a can be converted from String to &str with an ampersand (&). I don't think this is quite right, because it looks like it's expecting a [u8] and not a &str ² Lemmie try that:

extern crate chrono;

use std::io::prelude::*;
use std::fs::File;
use std::io;
use chrono::*;

fn log_time(filename: &'static str) -> io::Result<()> {

    let local: DateTime<Local> = Local::now();
    let time_str = local.format("%Y").to_string();
    let mut f = try!(File::create(filename));
    try!(f.write_all(&time_str));
    Ok(())
}

fn main() {
    match log_time("log.txt") {
        Ok(..) => println!("File created!"),
        Err(..) => println!("Error: could not create file.")
    }
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:13:22: 13:31 error: mismatched types:
 expected `&[u8]`,
    found `&collections::string::String`
(expected slice,
    found struct `collections::string::String`) [E0308]
src/main.rs:13     try!(f.write_all(&time_str));
                                    ^~~~~~~~~
<std macros>:1:1: 6:48 note: in expansion of try!
src/main.rs:13:5: 13:34 note: expansion site
error: aborting due to previous error
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

Well. Apparently, adding the ampersand just converted a String to an &String. That seems to directly contradict what the Rust book is saying, but I also probably don't know what is going on.

…And I just reached the end of the chapter on strings. Harumph. As far as I can tell, there isn't anything in here.

I walked away from this for a while (because, you know, life), and while I was gone it hit me. All this time, I have been reading u8 as a short form of UTF-8, but now that I think about it, it almost certainly actually means "unsigned 8-bit integer". And, I remember seeing an as_bytes method, so let me try that instead:

extern crate chrono;

use std::io::prelude::*;
use std::fs::File;
use std::io;
use chrono::*;

fn log_time(filename: &'static str) -> io::Result<()> {
    let local: DateTime<Local> = Local::now();
    let bytes = local.format("%Y").to_string().as_bytes();
    let mut f = try!(File::create(filename));
    try!(f.write_all(bytes));
    Ok(())
}

fn main() {
    match log_time("log.txt") {
        Ok(..) => println!("File created!"),
        Err(..) => println!("Error: could not create file.")
    }
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
main.rs:10:17: 10:47 error: borrowed value does not live long enough
main.rs:10     let bytes = local.format("%Y").to_string().as_bytes();
                           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
main.rs:10:59: 14:2 note: reference must be valid for the block suffix following statement 1 at 10:
58...
main.rs:10     let bytes = local.format("%Y").to_string().as_bytes();
main.rs:11     let mut f = try!(File::create(filename));
main.rs:12     try!(f.write_all(bytes));
main.rs:13     Ok(())
main.rs:14 }
main.rs:10:5: 10:59 note: ...but borrowed value is only valid for the statement at 10:4
main.rs:10     let bytes = local.format("%Y").to_string().as_bytes();
               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
main.rs:10:5: 10:59 help: consider using a `let` binding to increase its lifetime
main.rs:10     let bytes = local.format("%Y").to_string().as_bytes();
               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

Well, I hope this is progress. Does this error mean I fixed something, and there was something else wrong that was obscuring this problem? Did I introduce a whole new problem?

The strange thing about this error message is that it seems to be talking about error messages on the same line. I don't really understand most of it, but I'm thinking it is saying that I need to add a let in the middle of the sequence of method calls. Lets try:

fn log_time(filename: &'static str) -> io::Result<()> {
    let local: DateTime<Local> = Local::now();
    let formatted = local.format("%Y").to_string();
    let bytes = formatted.as_bytes();
    let mut f = try!(File::create(filename));
    try!(f.write_all(bytes));
    Ok(())
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
     Running `target/debug/simple-log`
File created!
$ cat log.txt
2015$

Great! All the pieces are here. Before I move on, I want to reflect that I find this a little disappointing. It seems like Rust should be able to infer the correct behavior in the previous snippet without my guidance.

Testing the script:

$ ls
Cargo.lock      Cargo.toml      log.txt         src             target
$ rm log.txt
$ cargo run
     Running `target/debug/simple-log`
File created!
$ cat log.txt
2015$ cargo run
     Running `target/debug/simple-log`
File created!
$ cat log.txt
2015$

4.2 Filling in Missing Pieces

A few problems:

No newline. This is really gross.
The format needs some work.
It appears that the old value is being erased by the new value.

Let's verify #3 by fixing the format. If the time changes between runs, then we will know that's what is happening.

The format method of DateTime uses the standard strftime formatting conventions. Ideally, I would like times to be something like:

Sat, Jun 6 2015 05:32:00 PM
Sun, Jun 7 2015 08:35:00 AM

…etc. This should be readable enough for me to use. After reading the documentation for a while, I've come up with this:

extern crate chrono;

use std::io::prelude::*;
use std::fs::File;
use std::io;
use chrono::*;

fn log_time(filename: &'static str) -> io::Result<()> {
    let local: DateTime<Local> = Local::now();
    let formatted = local.format("%a, %b %d %Y %I:%M:%S %p\n").to_string();
    let bytes = formatted.as_bytes();
    let mut f = try!(File::create(filename));
    try!(f.write_all(bytes));
    Ok(())
}

fn main() {
    match log_time("log.txt") {
        Ok(..) => println!("File created!"),
        Err(..) => println!("Error: could not create file.")
    }
}

Testing it:

$ rm log.txt
$ cargo run
     Running `target/debug/simple-log`
File created!
$ cat log.txt
Sun, Jun 07 2015 06:37:21 PM
$ sleep 5; cargo run
     Running `target/debug/simple-log`
File created!
$ cat log.txt
Sun, Jun 07 2015 06:37:41 PM

So, clearly the program is overwriting the log entries, which tbqh is what I expect, as I remember the documentation for File::create specifying that this is what would happen. So, I need to look at the documentation for manipulating files again.

I did some searching around, and basically finding the answer to this isn't trivial. After a while I found the documentation for std::path::Path, which has an exists method.

At this point, the interactions between types in my application is becoming increasingly hard to manage. I feel nervous, so I will commit before continuing.

I want to pull the time entry string generation out of the log_time function because it seems like the entry formatting/creation is distinct from the file manipulation code. So, trying this:

extern crate chrono;

use std::io::prelude::*;
use std::fs::File;
use std::io;
use chrono::*;


fn log_time_entry() -> String {
    let local: DateTime<Local> = Local::now();
    let formatted = local.format("%a, %b %d %Y %I:%M:%S %p\n").to_string();
    formatted
}

fn log_time(filename: &'static str) -> io::Result<()> {
    let bytes = log_time_entry().as_bytes();
    let mut f = try!(File::create(filename));
    try!(f.write_all(bytes));
    Ok(())
}

fn main() {
    match log_time("log.txt") {
        Ok(..) => println!("File created!"),
        Err(..) => println!("Error: could not create file.")
    }
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:16:17: 16:33 error: borrowed value does not live long enough
src/main.rs:16     let bytes = log_time_entry().as_bytes();
                               ^~~~~~~~~~~~~~~~
src/main.rs:16:45: 20:2 note: reference must be valid for the block suffix following statement 0 at
 16:44...
src/main.rs:16     let bytes = log_time_entry().as_bytes();
src/main.rs:17     let mut f = try!(File::create(filename));
src/main.rs:18     try!(f.write_all(bytes));
src/main.rs:19     Ok(())
src/main.rs:20 }
src/main.rs:16:5: 16:45 note: ...but borrowed value is only valid for the statement at 16:4
src/main.rs:16     let bytes = log_time_entry().as_bytes();
                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
src/main.rs:16:5: 16:45 help: consider using a `let` binding to increase its lifetime
src/main.rs:16     let bytes = log_time_entry().as_bytes();
                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to previous error
Could not compile `simple-log`.

To learn more, run the command again with --verbose.

So, this looks just like the problem I had earlier. Does borrowing/ownership require that a function have an explicit reference to resources? That seems a little strange. I will try to fix it again:

extern crate chrono;

use std::io::prelude::*;
use std::fs::File;
use std::io;
use chrono::*;

fn formatted_time_entry() -> String {
    let local: DateTime<Local> = Local::now();
    let formatted = local.format("%a, %b %d %Y %I:%M:%S %p\n").to_string();
    formatted
}

fn log_time(filename: &'static str) -> io::Result<()> {
    let entry = formatted_time_entry();
    let bytes = entry.as_bytes();

    let mut f = try!(File::create(filename));
    try!(f.write_all(bytes));
    Ok(())
}

fn main() {
    match log_time("log.txt") {
        Ok(..) => println!("File created!"),
        Err(..) => println!("Error: could not create file.")
    }
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
     Running `target/debug/simple-log`
File created!

So, adding an explicit reference seems to be the solution. Whatever. It is an easy rule to learn and follow.

Next I want to extract the file manipulation code to its own function:

extern crate chrono;

use std::io::prelude::*;
use std::fs::File;
use std::io;
use chrono::*;

fn formatted_time_entry() -> String {
    let local: DateTime<Local> = Local::now();
    let formatted = local.format("%a, %b %d %Y %I:%M:%S %p\n").to_string();
    formatted
}

fn record_entry_in_log(filename: &str, bytes: &[u8]) -> io::Result<()> {
    let mut f = try!(File::create(filename));
    try!(f.write_all(bytes));
    Ok(())
}

fn log_time(filename: &'static str) -> io::Result<()> {
    let entry = formatted_time_entry();
    let bytes = entry.as_bytes();

    try!(record_entry_in_log(filename, &bytes));
    Ok(())
}

fn main() {
    match log_time("log.txt") {
        Ok(..) => println!("File created!"),
        Err(..) => println!("Error: could not create file.")
    }
}

And this works. I made some initial errors, but they were quickly corrected and was all stuff that has been covered here before.

Looking into the documentation for std::fs::File, I notice a reference to std::fs::OpenOptions, which is exactly what I have been looking for. It would definitely be better than using std::path.

My first attempt:

extern crate chrono;

use std::io::prelude::*;
use std::fs::{File,OpenOptions};
use std::io;
use chrono::{DateTime,Local};


fn formatted_time_entry() -> String {
    let local: DateTime<Local> = Local::now();
    let formatted = local.format("%a, %b %d %Y %I:%M:%S %p\n").to_string();
    formatted
}

fn record_entry_in_log(filename: &str, bytes: &[u8]) -> io::Result<()> {
    let mut file = try!(OpenOptions::new().
                        append(true).
                        create(true).
                        open(filename));
    try!(file.write_all(bytes));
    Ok(())
}

fn log_time(filename: &'static str) -> io::Result<()> {
    let entry = formatted_time_entry();
    let bytes = entry.as_bytes();

    try!(record_entry_in_log(filename, &bytes));
    Ok(())
}

fn main() {
    match log_time("log.txt") {
        Ok(..) => println!("File created!"),
        Err(..) => println!("Error: could not create file.")
    }
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:4:15: 4:19 warning: unused import, #[warn(unused_imports)] on by default
src/main.rs:4 use std::fs::{File,OpenOptions};
                            ^~~~
     Running `target/debug/simple-log`
Error: could not create file.

Interesting. I see that it is actually creating the file, after which I notice this is the message I've hard-coded into main. Ugh; I think this will work:

extern crate chrono;

use std::io::prelude::*;
use std::fs::{File,OpenOptions};
use std::io;
use chrono::{DateTime,Local};


fn formatted_time_entry() -> String {
    let local: DateTime<Local> = Local::now();
    let formatted = local.format("%a, %b %d %Y %I:%M:%S %p\n").to_string();
    formatted
}

fn record_entry_in_log(filename: &str, bytes: &[u8]) -> io::Result<()> {
    let mut file = try!(OpenOptions::new().
                        append(true).
                        create(true).
                        open(filename));
    try!(file.write_all(bytes));
    Ok(())
}

fn log_time(filename: &'static str) -> io::Result<()> {
    let entry = formatted_time_entry();
    let bytes = entry.as_bytes();

    try!(record_entry_in_log(filename, &bytes));
    Ok(())
}

fn main() {
    match log_time("log.txt") {
        Ok(..) => println!("File created!"),
        Err(e) => println!("Error: {}", e)
    }
}

$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:4:15: 4:19 warning: unused import, #[warn(unused_imports)] on by default
src/main.rs:4 use std::fs::{File,OpenOptions};
                            ^~~~
     Running `target/debug/simple-log`
Error: Bad file descriptor (os error 9)

Weird. Searching for this "bad file descriptor" error message seems to indicate that this happens when a file descriptor is used has been closed. what happens if I comment out the file.write_all call?

$ rm log.txt
$ cargo run
   Compiling simple-log v0.1.0 (file:///Users/joel/Projects/simple-log)
src/main.rs:3:5: 3:25 warning: unused import, #[warn(unused_imports)] on by default
src/main.rs:3 use std::io::prelude::*;
                  ^~~~~~~~~~~~~~~~~~~~
src/main.rs:4:15: 4:19 warning: unused import, #[warn(unused_imports)] on by default
src/main.rs:4 use std::fs::{File,OpenOptions};
                            ^~~~
src/main.rs:15:40: 15:45 warning: unused variable: `bytes`, #[warn(unused_variables)] on by default
src/main.rs:15 fn record_entry_in_log(filename: &str, bytes: &[u8]) -> io::Result<()> {
                                                      ^~~~~
src/main.rs:16:9: 16:17 warning: unused variable: `file`, #[warn(unused_variables)] on by default
src/main.rs:16     let mut file = try!(OpenOptions::new().
                       ^~~~~~~~
src/main.rs:16:9: 16:17 warning: variable does not need to be mutable, #[warn(unused_mut)] on by de
fault
src/main.rs:16     let mut file = try!(OpenOptions::new().
                       ^~~~~~~~
     Running `target/debug/simple-log`
File created!
$ ls
Cargo.lock      Cargo.toml      log.txt         src             target

Unsurprisingly, there are a bunch unused messages, but aside from that the file is indeed created.

It seems a little silly, but I tried adding .write(true) to the chain of functions, and it worked. It seems like .append(true) should imply .write(true), but I guess it doesn't.

And with that, its working! The final version:

extern crate chrono;

use std::io::prelude::*;
use std::fs::{File,OpenOptions};
use std::io;
use chrono::{DateTime,Local};


fn formatted_time_entry() -> String {
    let local: DateTime<Local> = Local::now();
    let formatted = local.format("%a, %b %d %Y %I:%M:%S %p\n").to_string();
    formatted
}

fn record_entry_in_log(filename: &str, bytes: &[u8]) -> io::Result<()> {
    let mut file = try!(OpenOptions::new().
                        append(true).
                        write(true).
                        create(true).
                        open(filename));
    try!(file.write_all(bytes));
    Ok(())
}

fn log_time(filename: &'static str) -> io::Result<()> {
    let entry = formatted_time_entry();
    let bytes = entry.as_bytes();

    try!(record_entry_in_log(filename, &bytes));
    Ok(())
}

fn main() {
    match log_time("log.txt") {
        Ok(..) => println!("File created!"),
        Err(e) => println!("Error: {}", e)
    }
}

$ ls
Cargo.lock      Cargo.toml      src             target
$ cargo run
     Running `target/debug/simple-log`
File created!
$ cargo run
     Running `target/debug/simple-log`
File created!
$ cat log.txt
Sun, Jun 07 2015 10:40:01 PM
Sun, Jun 07 2015 10:40:05 PM

5 Conclusion & Next Steps

Rust is getting easier for me. I now have some reasonably factored code to work with, and I feel fairly confident about starting on the next part of the application.

When I was first planning this series, I expected the next task to be integrating the logging code with the nickel.rs code, but at this point I think it is going to be pretty simple. I suspect that the next difficult part will be handling option parsing.

—

Series: A Simple Web App in Rust

Footnotes:

Having many types of strings is a completely reasonable thing. Strings are a complicated subject and hard to get right. Unfortunately, at first glance strings seem very simple, and this kind of things seems like needless complication

I basically have no idea what I'm talking about here. These are just things I've seen that I'm to make sense of.

Joel's Journal

Dockerizing my Jekyll Blog

Table of Contents

1 Background

2 End Goal

3 Lessons

3.1 When building docker images, look for existing Dockerfile examples

3.2 Inter-application communication is trickier

3.3 Use an entrypoint script

3.4 Docker tools are weird

4 Conclusion

Footnotes:

A Simple Web App in Rust, Conclusion: Putting Rust Aside for Now

Writing a 'Human Resource Machine' Emulator in Elm

Table of Contents

1 Goals and Ideas

2 MVP

3 The Program

3.1 Model

3.2 Program Scaffolding & View

3.3 The Update

Homebrew Command `brew leaves`: List Packages Without Dependents

How to Print a Struct in Rust

A Simple Web App in Rust, Part 4 -- CLI Option Parsing

Table of Contents

1 Back from Hiatus

2 Intro

3 Requirements

4 Implementation

5 A Rant

6 Continuing

7 More Debugging

8 Regrouping

9 Refactoring

10 Conclusions & Retrospective on Part 4

A Simple Web App in Rust, Part 3 -- Integration

Table of Contents

1 Previously

1.1 Review

2 Combining the Code: Fisticuffing with the Type System

3 Fin

Rust, the Language for Growth

Dealing With the Rust Shift in Perspective

A Simple Web App in Rust, Part 2b

Table of Contents

1 The Series

2 Using Chrono

3 Writing the Date/Time to a File

4 Building a File Logger

4.1 Misunderstanding u8

4.2 Filling in Missing Pieces

5 Conclusion & Next Steps

Footnotes:

3.1 When building docker images, look for existing `Dockerfile` examples

4.1 Misunderstanding `u8`