Bubble errors through to browser

src/main.rs

         let mut path: PathBuf = get_posts_directory()?;
         let filename = format!("{}.json", self.id);
         path = path.join(&filename);
-        let mut file = match File::create(&path) {
-            Err(why) => panic!("couldn't create {}: {}", self.id, why),
-            Ok(file) => file,
-        };
-        match file.write_all(serde_json::to_string(&self)?.as_bytes()) {
-            Err(why) => Err(Error::new(
-                ErrorKind::Other,
-                format!("couldn't write to {}.json: {}", self.id, why),
-            )),
-            Ok(_) => Ok(()),
-        }
+        let mut file = File::create(&path)?;
+        file.write_all(serde_json::to_string(&self)?.as_bytes())?;
+        Ok(())
     }
 }
 
 }
 
 async fn read_all_posts() -> Result<Vec<Post>, Error> {
-    let path = get_posts_directory()?;
+    let path = match get_posts_directory() {
+        Ok(p) => Ok(p),
+        Err(_) => Err(Error::new(ErrorKind::Other, "POSTS_DIR variable is not set"))
+    }?;
     let mut posts: Vec<Post> = vec![];
 
-    for file in read_dir(path)? {
+    let files = match read_dir(path) {
+        Ok(f) => Ok(f),
+        Err(_) => Err(Error::new(ErrorKind::Other, "Posts directory does not exist"))
+    }?;
+
+    for file in files {
         let file = file?;
         if let Some("json") = file.path().extension().and_then(OsStr::to_str) {
-            let contents = read_to_string(file.path()).await?;
-            let mut post: Post = serde_json::from_str(&contents)?;
+            let contents = match read_to_string(file.path()).await {
+                Ok(c) => Ok(c),
+                Err(_) => Err(Error::new(ErrorKind::Other, format!("Error reading post {:?}", file.path())))
+            }?;
+            let mut post: Post = match serde_json::from_str(&contents) {
+                Ok(p) => Ok(p),
+                Err(_) => Err(Error::new(ErrorKind::Other, format!("Error deserializing post")))
+            }?;
             post.body = post.body.replace("\n", "<br>");
             posts.push(post);
         }
 
     app.with(After(|mut res: Response| async {
         if let Some(err) = res.downcast_error::<async_std::io::Error>() {
-            println!("{:?}", res);
-            if let ErrorKind::NotFound = err.kind() {
-                res.set_status(StatusCode::NotFound);
-            }
+            let tera = Tera::new("templates/**/*.html")?;
+            let mut context = Context::new();
+            context.insert("error", &err.to_string());
+            let html = tera.render("error.html", &context)?;
+            res.set_body(html);
+            res.set_status(StatusCode::InternalServerError);
         }
 
         Ok(res)

templates/error.html

+{% extends "layout.html" %} {% block content %}
+<div class="error">
+  <h1 class="error__heading">Error:</h1>
+  <p class="error__message">{{ error }}</p>
+</div>
+{% endblock %}

templates/layout.html

         font-weight: normal;
       }
 
+      .error {
+        color: #942626;
+        text-align: center;
+      }
+
+      .error__heading {
+        margin: 2em 0 1em;
+      }
+
+      .error__message {
+        font-size: 18px;
+      }
+
       @media (max-width: 500px) {
         .form__button {
           width: 100%;