Returning cache headers for network content (#3123)

dapps/src/page/builtin.rs

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
-use page::handler;
+use page::{handler, PageCache};
 use std::sync::Arc;
 use endpoint::{Endpoint, EndpointInfo, EndpointPath, Handler};
 use parity_dapps::{WebApp, File, Info};
@@ -80,6 +80,7 @@ impl<T: WebApp> Endpoint for PageEndpoint<T> {
 			prefix: self.prefix.clone(),
 			path: path,
 			file: handler::ServedFile::new(self.safe_to_embed_at_port.clone()),
+			cache: PageCache::Disabled,
 			safe_to_embed_at_port: self.safe_to_embed_at_port.clone(),
 		})
 	}

dapps/src/page/handler.rs

@@ -15,6 +15,8 @@
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::io::Write;
+use time::{self, Duration};
+
 use hyper::header;
 use hyper::server;
 use hyper::uri::RequestUri;
@@ -69,6 +71,19 @@ impl<T: Dapp> ServedFile<T> {
 	}
 }
 
+/// Defines what cache headers should be appended to returned resources.
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub enum PageCache {
+	Enabled,
+	Disabled,
+}
+
+impl Default for PageCache {
+	fn default() -> Self {
+		PageCache::Disabled
+	}
+}
+
 /// A handler for a single webapp.
 /// Resolves correct paths and serves as a plumbing code between
 /// hyper server and dapp.
@@ -83,6 +98,8 @@ pub struct PageHandler<T: Dapp> {
 	pub path: EndpointPath,
 	/// Flag indicating if the file can be safely embeded (put in iframe).
 	pub safe_to_embed_at_port: Option<u16>,
+	/// Cache settings for this page.
+	pub cache: PageCache,
 }
 
 impl<T: Dapp> PageHandler<T> {
@@ -129,9 +146,19 @@ impl<T: Dapp> server::Handler<HttpStream> for PageHandler<T> {
 			ServedFile::File(ref f) => {
 				res.set_status(StatusCode::Ok);
 
+				if let PageCache::Enabled = self.cache {
+					let mut headers = res.headers_mut();
+					let validity = Duration::days(365);
+					headers.set(header::CacheControl(vec![
+						header::CacheDirective::Public,
+						header::CacheDirective::MaxAge(validity.num_seconds() as u32),
+					]));
+					headers.set(header::Expires(header::HttpDate(time::now() + validity)));
+				}
+
 				match f.content_type().parse() {
 					Ok(mime) => res.headers_mut().set(header::ContentType(mime)),
-					Err(()) => debug!(target: "page_handler", "invalid MIME type: {}", f.content_type()),
+					Err(()) => debug!(target: "dapps", "invalid MIME type: {}", f.content_type()),
 				}
 
 				// Security headers:
@@ -218,6 +245,7 @@ fn should_extract_path_with_appid() {
 			using_dapps_domains: true,
 		},
 		file: ServedFile::new(None),
+		cache: Default::default(),
 		safe_to_embed_at_port: None,
 	};
 

dapps/src/page/local.rs

@@ -18,7 +18,7 @@ use mime_guess;
 use std::io::{Seek, Read, SeekFrom};
 use std::fs;
 use std::path::{Path, PathBuf};
-use page::handler;
+use page::handler::{self, PageCache};
 use endpoint::{Endpoint, EndpointInfo, EndpointPath, Handler};
 
 #[derive(Debug, Clone)]
@@ -26,24 +26,27 @@ pub struct LocalPageEndpoint {
 	path: PathBuf,
 	mime: Option<String>,
 	info: Option<EndpointInfo>,
+	cache: PageCache,
 	embeddable_at: Option<u16>,
 }
 
 impl LocalPageEndpoint {
-	pub fn new(path: PathBuf, info: EndpointInfo, embeddable_at: Option<u16>) -> Self {
+	pub fn new(path: PathBuf, info: EndpointInfo, cache: PageCache, embeddable_at: Option<u16>) -> Self {
 		LocalPageEndpoint {
 			path: path,
 			mime: None,
 			info: Some(info),
+			cache: cache,
 			embeddable_at: embeddable_at,
 		}
 	}
 
-	pub fn single_file(path: PathBuf, mime: String) -> Self {
+	pub fn single_file(path: PathBuf, mime: String, cache: PageCache) -> Self {
 		LocalPageEndpoint {
 			path: path,
 			mime: Some(mime),
 			info: None,
+			cache: cache,
 			embeddable_at: None,
 		}
 	}
@@ -66,6 +69,7 @@ impl Endpoint for LocalPageEndpoint {
 				path: path,
 				file: handler::ServedFile::new(None),
 				safe_to_embed_at_port: self.embeddable_at,
+				cache: self.cache,
 			})
 		} else {
 			Box::new(handler::PageHandler {
@@ -74,6 +78,7 @@ impl Endpoint for LocalPageEndpoint {
 				path: path,
 				file: handler::ServedFile::new(None),
 				safe_to_embed_at_port: self.embeddable_at,
+				cache: self.cache,
 			})
 		}
 	}

dapps/src/page/mod.rs

@@ -21,4 +21,5 @@ mod handler;
 
 pub use self::local::LocalPageEndpoint;
 pub use self::builtin::PageEndpoint;
+pub use self::handler::PageCache;