third_party/rust_crates/vendor/rouille/examples/database.rs - fuchsia - Git at Google

 // Copyright (c) 2016 The Rouille developers
 // Licensed under the Apache License, Version 2.0
 // <LICENSE-APACHE or
 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT
 // license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
 // at your option. All files in the project carrying such
 // notice may not be copied, modified, or distributed except
 // according to those terms.

 #[macro_use]
 extern crate rouille;
 extern crate postgres;
 extern crate serde;
 #[macro_use]
 extern crate serde_derive;

 use std::sync::Mutex;

 use postgres::Connection;
 use postgres::TlsMode;
 use postgres::transaction::Transaction;

 use rouille::Request;
 use rouille::Response;

 fn main() {
     // This example demonstrates how to connect to a database and perform queries when the client
     // performs a request.
     // The server created in this example uses a REST API.

     // The first thing we do is try to connect to the database.
     //
     // One important thing to note here is that we wrap a `Mutex` around the connection. Since the
     // request handler can be called multiple times in parallel, everything that we use in it must
     // be thread-safe. By default the PostgresSQL connection isn't thread-safe, so we need a mutex
     // to make it thread-safe.
     //
     // Not wrapping a mutex around the database would lead to a compilation error when we attempt
     // to use the variable `db` from within the closure passed to `start_server`.
     let db = {
         let db = Connection::connect("postgres://test:test@localhost/test", TlsMode::None);
         Mutex::new(db.expect("Failed to connect to database"))
     };

     // We perform some initialization for the sake of the example.
     // In a real application you probably want to have a migrations system. This is out of scope
     // of rouille.
     {
         let sql = "CREATE TABLE IF NOT EXISTS notes (
                     id SERIAL PRIMARY KEY,
                     content TEXT NOT NULL
                    );";
         db.lock().unwrap().execute(sql, &[]).expect("Failed to initialize database");
     }

     // Small message so that people don't need to read the source code.
     // Note that like all the other examples, we only listen on `localhost`, so you can't access this server
     // from any machine other than your own.
     println!("Now listening on localhost:8000");

     // Now the server starts listening. The `move` keyword will ensure that we move the `db` variable
     // into the closure. Not putting `move` here would result in a compilation error.
     //
     // Note that in an ideal world, `move` wouldn't be necessary here. Unfortunately Rust isn't
     // smart enough yet to understand that the database can't be destroyed while we still use it.
     rouille::start_server("localhost:8000", move |request| {
         // Since we wrapped the database connection around a `Mutex`, we lock it here before usage.
         //
         // This will give us exclusive access to the database connection for the handling of this
         // request. Unfortunately the consequence is that if a request is made while another one
         // is already being processed, the second one will have to wait for the first one to
         // complete.
         //
         // In a real application you probably want to create multiple connections instead of just
         // one, and make each request use a different connection.
         //
         // In addition to this, if a panic happens while the `Mutex` is locked then the database
         // connection will likely be in a corrupted state and the next time the mutex is locked
         // it will panic. This is another good reason to use multiple connections.
         let db = db.lock().unwrap();

         // Start a transaction so that if a panic happens during the processing of the request,
         // any change made to the database will be rolled back.
         let db = db.transaction().unwrap();

         // For better readability, we handle the request in a separate function.
         let response = note_routes(&request, &db);

         // If the response is a success, we commit the transaction before returning. It's only at
         // this point that data are actually written in the database.
         if response.is_success() {
             db.commit().unwrap();
         }

         response
     });
 }

 // This function actually handles the request.
 fn note_routes(request: &Request, db: &Transaction) -> Response {
     router!(request,
         (GET) (/) => {
             // For the sake of the example we just put a dummy route for `/` so that you see
             // something if you connect to the server with a browser.
             Response::text("Hello! Unfortunately there is nothing to see here.")
         },

         (GET) (/notes) => {
             // This route returns the list of notes. We perform the query and output it as JSON.

             #[derive(Serialize)]
             struct Elem { id: String }

             let mut out = Vec::new();
             // We perform the query and iterate over the rows, writing each row to `out`.
             for row in &db.query("SELECT id FROM notes", &[]).unwrap() {
                 let id: i32 = row.get(0);
                 out.push(Elem { id: format!("/note/{}", id) });
             }

             Response::json(&out)
         },

         (GET) (/note/{id: i32}) => {
             // This route returns the content of a note, if it exists.

             // Note that this code is a bit unergonomic, but this is mostly a problem with the
             // database client library and not rouille itself.

             // To do so, we first create a variable that will receive the content of the note.
             let mut content: Option<String> = None;
             // And then perform the query and write to `content`. This line can only panic if the
             // SQL is malformed.
             for row in &db.query("SELECT content FROM notes WHERE id = $1", &[&id]).unwrap() {
                 content = Some(row.get(0));
             }

             // If `content` is still empty at this point, this means that the note doesn't
             // exist in the database. Otherwise, we return the content.
             match content {
                 Some(content) => Response::text(content),
                 None => Response::empty_404(),
             }
         },

         (PUT) (/note/{id: i32}) => {
             // This route modifies the content of an existing note.

             // We start by reading the body of the HTTP request into a `String`.
             let body = try_or_400!(rouille::input::plain_text_body(&request));

             // And write the content with a query. This line can only panic if the
             // SQL is malformed.
             let updated = db.execute("UPDATE notes SET content = $2 WHERE id = $1",
                                      &[&id, &body]).unwrap();

             // We determine whether the note existed based on the number of rows that
             // were modified.
             if updated >= 1 {
                 Response::text("The note has been updated")
             } else {
                 Response::empty_404()
             }
         },

         (POST) (/note) => {
             // This route creates a new note whose initial content is the body.

             // We start by reading the body of the HTTP request into a `String`.
             let body = try_or_400!(rouille::input::plain_text_body(&request));

             // To do so, we first create a variable that will receive the content.
             let mut id: Option<i32> = None;
             // And then perform the query and write to `content`. This line can only panic if the
             // SQL is malformed.
             for row in &db.query("INSERT INTO notes(content) VALUES ($1) RETURNING id", &[&body]).unwrap() {
                 id = Some(row.get(0));
             }

             let id = id.unwrap();

             let mut response = Response::text("The note has been created");
             response.status_code = 201;
             response.headers.push(("Location".into(), format!("/note/{}", id).into()));
             response
         },

         (DELETE) (/note/{id: i32}) => {
             // This route deletes a note. This line can only panic if the
             // SQL is malformed.
             db.execute("DELETE FROM notes WHERE id = $1", &[&id]).unwrap();
             Response::text("")
         },

         // If none of the other blocks matches the request, return a 404 response.
         _ => Response::empty_404()
     )
 }
	// Copyright (c) 2016 The Rouille developers
	// Licensed under the Apache License, Version 2.0
	// <LICENSE-APACHE or
	// http://www.apache.org/licenses/LICENSE-2.0> or the MIT
	// license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
	// at your option. All files in the project carrying such
	// notice may not be copied, modified, or distributed except
	// according to those terms.

	#[macro_use]
	extern crate rouille;
	extern crate postgres;
	extern crate serde;
	#[macro_use]
	extern crate serde_derive;

	use std::sync::Mutex;

	use postgres::Connection;
	use postgres::TlsMode;
	use postgres::transaction::Transaction;

	use rouille::Request;
	use rouille::Response;

	fn main() {
	// This example demonstrates how to connect to a database and perform queries when the client
	// performs a request.
	// The server created in this example uses a REST API.

	// The first thing we do is try to connect to the database.
	//
	// One important thing to note here is that we wrap a `Mutex` around the connection. Since the
	// request handler can be called multiple times in parallel, everything that we use in it must
	// be thread-safe. By default the PostgresSQL connection isn't thread-safe, so we need a mutex
	// to make it thread-safe.
	//
	// Not wrapping a mutex around the database would lead to a compilation error when we attempt
	// to use the variable `db` from within the closure passed to `start_server`.
	let db = {
	let db = Connection::connect("postgres://test:test@localhost/test", TlsMode::None);
	Mutex::new(db.expect("Failed to connect to database"))
	};

	// We perform some initialization for the sake of the example.
	// In a real application you probably want to have a migrations system. This is out of scope
	// of rouille.
	{
	let sql = "CREATE TABLE IF NOT EXISTS notes (
	id SERIAL PRIMARY KEY,
	content TEXT NOT NULL
	);";
	db.lock().unwrap().execute(sql, &[]).expect("Failed to initialize database");
	}

	// Small message so that people don't need to read the source code.
	// Note that like all the other examples, we only listen on `localhost`, so you can't access this server
	// from any machine other than your own.
	println!("Now listening on localhost:8000");

	// Now the server starts listening. The `move` keyword will ensure that we move the `db` variable
	// into the closure. Not putting `move` here would result in a compilation error.
	//
	// Note that in an ideal world, `move` wouldn't be necessary here. Unfortunately Rust isn't
	// smart enough yet to understand that the database can't be destroyed while we still use it.
	rouille::start_server("localhost:8000", move \|request\| {
	// Since we wrapped the database connection around a `Mutex`, we lock it here before usage.
	//
	// This will give us exclusive access to the database connection for the handling of this
	// request. Unfortunately the consequence is that if a request is made while another one
	// is already being processed, the second one will have to wait for the first one to
	// complete.
	//
	// In a real application you probably want to create multiple connections instead of just
	// one, and make each request use a different connection.
	//
	// In addition to this, if a panic happens while the `Mutex` is locked then the database
	// connection will likely be in a corrupted state and the next time the mutex is locked
	// it will panic. This is another good reason to use multiple connections.
	let db = db.lock().unwrap();

	// Start a transaction so that if a panic happens during the processing of the request,
	// any change made to the database will be rolled back.
	let db = db.transaction().unwrap();

	// For better readability, we handle the request in a separate function.
	let response = note_routes(&request, &db);

	// If the response is a success, we commit the transaction before returning. It's only at
	// this point that data are actually written in the database.
	if response.is_success() {
	db.commit().unwrap();
	}

	response
	});
	}

	// This function actually handles the request.
	fn note_routes(request: &Request, db: &Transaction) -> Response {
	router!(request,
	(GET) (/) => {
	// For the sake of the example we just put a dummy route for `/` so that you see
	// something if you connect to the server with a browser.
	Response::text("Hello! Unfortunately there is nothing to see here.")
	},

	(GET) (/notes) => {
	// This route returns the list of notes. We perform the query and output it as JSON.

	#[derive(Serialize)]
	struct Elem { id: String }

	let mut out = Vec::new();
	// We perform the query and iterate over the rows, writing each row to `out`.
	for row in &db.query("SELECT id FROM notes", &[]).unwrap() {
	let id: i32 = row.get(0);
	out.push(Elem { id: format!("/note/{}", id) });
	}

	Response::json(&out)
	},

	(GET) (/note/{id: i32}) => {
	// This route returns the content of a note, if it exists.

	// Note that this code is a bit unergonomic, but this is mostly a problem with the
	// database client library and not rouille itself.

	// To do so, we first create a variable that will receive the content of the note.
	let mut content: Option<String> = None;
	// And then perform the query and write to `content`. This line can only panic if the
	// SQL is malformed.
	for row in &db.query("SELECT content FROM notes WHERE id = $1", &[&id]).unwrap() {
	content = Some(row.get(0));
	}

	// If `content` is still empty at this point, this means that the note doesn't
	// exist in the database. Otherwise, we return the content.
	match content {
	Some(content) => Response::text(content),
	None => Response::empty_404(),
	}
	},

	(PUT) (/note/{id: i32}) => {
	// This route modifies the content of an existing note.

	// We start by reading the body of the HTTP request into a `String`.
	let body = try_or_400!(rouille::input::plain_text_body(&request));

	// And write the content with a query. This line can only panic if the
	// SQL is malformed.
	let updated = db.execute("UPDATE notes SET content = $2 WHERE id = $1",
	&[&id, &body]).unwrap();

	// We determine whether the note existed based on the number of rows that
	// were modified.
	if updated >= 1 {
	Response::text("The note has been updated")
	} else {
	Response::empty_404()
	}
	},

	(POST) (/note) => {
	// This route creates a new note whose initial content is the body.

	// We start by reading the body of the HTTP request into a `String`.
	let body = try_or_400!(rouille::input::plain_text_body(&request));

	// To do so, we first create a variable that will receive the content.
	let mut id: Option<i32> = None;
	// And then perform the query and write to `content`. This line can only panic if the
	// SQL is malformed.
	for row in &db.query("INSERT INTO notes(content) VALUES ($1) RETURNING id", &[&body]).unwrap() {
	id = Some(row.get(0));
	}

	let id = id.unwrap();

	let mut response = Response::text("The note has been created");
	response.status_code = 201;
	response.headers.push(("Location".into(), format!("/note/{}", id).into()));
	response
	},

	(DELETE) (/note/{id: i32}) => {
	// This route deletes a note. This line can only panic if the
	// SQL is malformed.
	db.execute("DELETE FROM notes WHERE id = $1", &[&id]).unwrap();
	Response::text("")
	},

	// If none of the other blocks matches the request, return a 404 response.
	_ => Response::empty_404()
	)
	}