forked/hyper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(header): change HttpDate to opaque over SystemTime

Browse Source 
This removes the need for someone to use the `time` crate to create a
date compatible with HTTP headers. It now works with the `SystemTime`
type from the standard library.

BREAKING CHANGE: `HttpDate` no longer has public fields. Convert between
  `HttpDate` and `SystemTime` as needed.
This commit is contained in:
Sean McArthur
2017-04-24 15:09:10 -07:00
parent 011f28cb18
commit 316c6fad30
10 changed files with 106 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
src/header/common/date.rs
View File

@@ -2,31 +2,25 @@ use header::HttpDate;
header! { header! {
/// `Date` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-7.1.1.2) /// `Date` header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-7.1.1.2)
/// ///
/// The `Date` header field represents the date and time at which the /// The `Date` header field represents the date and time at which the
/// message was originated. /// message was originated.
/// ///
/// # ABNF /// # ABNF
/// ```plain /// ```plain
/// Date = HTTP-date /// Date = HTTP-date
/// ``` /// ```
/// ///
/// # Example values /// # Example values
/// * `Tue, 15 Nov 1994 08:12:31 GMT` /// * `Tue, 15 Nov 1994 08:12:31 GMT`
/// ///
/// # Example /// # Example
/// ``` /// ```
/// # extern crate time; /// use hyper::header::{Headers, Date};
/// # extern crate hyper; /// use std::time::SystemTime;
/// # fn main() { ///
/// // extern crate time;
///
/// use hyper::header::{Headers, Date, HttpDate};
/// use time;
///
/// let mut headers = Headers::new(); /// let mut headers = Headers::new();
/// headers.set(Date(HttpDate(time::now()))); /// headers.set(Date(SystemTime::now().into()));
/// # }
/// ``` /// ```
(Date, "Date") => [HttpDate] (Date, "Date") => [HttpDate]

25
src/header/common/expires.rs
View File

@@ -2,35 +2,30 @@ use header::HttpDate;
header! { header! {
/// `Expires` header, defined in [RFC7234](http://tools.ietf.org/html/rfc7234#section-5.3) /// `Expires` header, defined in [RFC7234](http://tools.ietf.org/html/rfc7234#section-5.3)
/// ///
/// The `Expires` header field gives the date/time after which the /// The `Expires` header field gives the date/time after which the
/// response is considered stale. /// response is considered stale.
/// ///
/// The presence of an Expires field does not imply that the original /// The presence of an Expires field does not imply that the original
/// resource will change or cease to exist at, before, or after that /// resource will change or cease to exist at, before, or after that
/// time. /// time.
/// ///
/// # ABNF /// # ABNF
/// ```plain /// ```plain
/// Expires = HTTP-date /// Expires = HTTP-date
/// ``` /// ```
/// ///
/// # Example values /// # Example values
/// * `Thu, 01 Dec 1994 16:00:00 GMT` /// * `Thu, 01 Dec 1994 16:00:00 GMT`
/// ///
/// # Example /// # Example
/// ``` /// ```
/// # extern crate hyper; /// use hyper::header::{Headers, Expires};
/// # extern crate time; /// use std::time::{SystemTime, Duration};
/// # fn main() { ///
/// // extern crate time;
///
/// use hyper::header::{Headers, Expires, HttpDate};
/// use time::{self, Duration};
///
/// let mut headers = Headers::new(); /// let mut headers = Headers::new();
/// headers.set(Expires(HttpDate(time::now() + Duration::days(1)))); /// let expiration = SystemTime::now() + Duration::from_secs(60 * 60 * 24);
/// # } /// headers.set(Expires(expiration.into()));
/// ``` /// ```
(Expires, "Expires") => [HttpDate] (Expires, "Expires") => [HttpDate]

23
src/header/common/if_modified_since.rs
View File

@@ -3,34 +3,29 @@ use header::HttpDate;
header! { header! {
/// `If-Modified-Since` header, defined in /// `If-Modified-Since` header, defined in
/// [RFC7232](http://tools.ietf.org/html/rfc7232#section-3.3) /// [RFC7232](http://tools.ietf.org/html/rfc7232#section-3.3)
/// ///
/// The `If-Modified-Since` header field makes a GET or HEAD request /// The `If-Modified-Since` header field makes a GET or HEAD request
/// method conditional on the selected representation's modification date /// method conditional on the selected representation's modification date
/// being more recent than the date provided in the field-value. /// being more recent than the date provided in the field-value.
/// Transfer of the selected representation's data is avoided if that /// Transfer of the selected representation's data is avoided if that
/// data has not changed. /// data has not changed.
/// ///
/// # ABNF /// # ABNF
/// ```plain /// ```plain
/// If-Unmodified-Since = HTTP-date /// If-Unmodified-Since = HTTP-date
/// ``` /// ```
/// ///
/// # Example values /// # Example values
/// * `Sat, 29 Oct 1994 19:43:31 GMT` /// * `Sat, 29 Oct 1994 19:43:31 GMT`
/// ///
/// # Example /// # Example
/// ``` /// ```
/// # extern crate hyper; /// use hyper::header::{Headers, IfModifiedSince};
/// # extern crate time; /// use std::time::{SystemTime, Duration};
/// # fn main() { ///
/// // extern crate time;
///
/// use hyper::header::{Headers, IfModifiedSince, HttpDate};
/// use time::{self, Duration};
///
/// let mut headers = Headers::new(); /// let mut headers = Headers::new();
/// headers.set(IfModifiedSince(HttpDate(time::now() - Duration::days(1)))); /// let modified = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
/// # } /// headers.set(IfModifiedSince(modified.into()));
/// ``` /// ```
(IfModifiedSince, "If-Modified-Since") => [HttpDate] (IfModifiedSince, "If-Modified-Since") => [HttpDate]

13
src/header/common/if_range.rs
View File

@@ -33,17 +33,12 @@ use header::{self, Header, Raw, EntityTag, HttpDate};
/// headers.set(IfRange::EntityTag(EntityTag::new(false, "xyzzy".to_owned()))); /// headers.set(IfRange::EntityTag(EntityTag::new(false, "xyzzy".to_owned())));
/// ``` /// ```
/// ``` /// ```
/// # extern crate hyper; /// use hyper::header::{Headers, IfRange};
/// # extern crate time; /// use std::time::{SystemTime, Duration};
/// # fn main() {
/// // extern crate time;
///
/// use hyper::header::{Headers, IfRange, HttpDate};
/// use time::{self, Duration};
/// ///
/// let mut headers = Headers::new(); /// let mut headers = Headers::new();
/// headers.set(IfRange::Date(HttpDate(time::now() - Duration::days(1)))); /// let fetched = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
/// # } /// headers.set(IfRange::Date(fetched.into()));
/// ``` /// ```
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Debug, PartialEq)]
pub enum IfRange { pub enum IfRange {

23
src/header/common/if_unmodified_since.rs
View File

@@ -3,34 +3,29 @@ use header::HttpDate;
header! { header! {
/// `If-Unmodified-Since` header, defined in /// `If-Unmodified-Since` header, defined in
/// [RFC7232](http://tools.ietf.org/html/rfc7232#section-3.4) /// [RFC7232](http://tools.ietf.org/html/rfc7232#section-3.4)
/// ///
/// The `If-Unmodified-Since` header field makes the request method /// The `If-Unmodified-Since` header field makes the request method
/// conditional on the selected representation's last modification date /// conditional on the selected representation's last modification date
/// being earlier than or equal to the date provided in the field-value. /// being earlier than or equal to the date provided in the field-value.
/// This field accomplishes the same purpose as If-Match for cases where /// This field accomplishes the same purpose as If-Match for cases where
/// the user agent does not have an entity-tag for the representation. /// the user agent does not have an entity-tag for the representation.
/// ///
/// # ABNF /// # ABNF
/// ```plain /// ```plain
/// If-Unmodified-Since = HTTP-date /// If-Unmodified-Since = HTTP-date
/// ``` /// ```
/// ///
/// # Example values /// # Example values
/// * `Sat, 29 Oct 1994 19:43:31 GMT` /// * `Sat, 29 Oct 1994 19:43:31 GMT`
/// ///
/// # Example /// # Example
/// ``` /// ```
/// # extern crate hyper; /// use hyper::header::{Headers, IfUnmodifiedSince};
/// # extern crate time; /// use std::time::{SystemTime, Duration};
/// # fn main() { ///
/// // extern crate time;
///
/// use hyper::header::{Headers, IfUnmodifiedSince, HttpDate};
/// use time::{self, Duration};
///
/// let mut headers = Headers::new(); /// let mut headers = Headers::new();
/// headers.set(IfUnmodifiedSince(HttpDate(time::now() - Duration::days(1)))); /// let modified = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
/// # } /// headers.set(IfUnmodifiedSince(modified.into()));
/// ``` /// ```
(IfUnmodifiedSince, "If-Unmodified-Since") => [HttpDate] (IfUnmodifiedSince, "If-Unmodified-Since") => [HttpDate]

23
src/header/common/last_modified.rs
View File

@@ -3,33 +3,28 @@ use header::HttpDate;
header! { header! {
/// `Last-Modified` header, defined in /// `Last-Modified` header, defined in
/// [RFC7232](http://tools.ietf.org/html/rfc7232#section-2.2) /// [RFC7232](http://tools.ietf.org/html/rfc7232#section-2.2)
/// ///
/// The `Last-Modified` header field in a response provides a timestamp /// The `Last-Modified` header field in a response provides a timestamp
/// indicating the date and time at which the origin server believes the /// indicating the date and time at which the origin server believes the
/// selected representation was last modified, as determined at the /// selected representation was last modified, as determined at the
/// conclusion of handling the request. /// conclusion of handling the request.
/// ///
/// # ABNF /// # ABNF
/// ```plain /// ```plain
/// Expires = HTTP-date /// Expires = HTTP-date
/// ``` /// ```
/// ///
/// # Example values /// # Example values
/// * `Sat, 29 Oct 1994 19:43:31 GMT` /// * `Sat, 29 Oct 1994 19:43:31 GMT`
/// ///
/// # Example /// # Example
/// ``` /// ```
/// # extern crate hyper; /// use hyper::header::{Headers, LastModified};
/// # extern crate time; /// use std::time::{SystemTime, Duration};
/// # fn main() { ///
/// // extern crate time;
///
/// use hyper::header::{Headers, LastModified, HttpDate};
/// use time::{self, Duration};
///
/// let mut headers = Headers::new(); /// let mut headers = Headers::new();
/// headers.set(LastModified(HttpDate(time::now() - Duration::days(1)))); /// let modified = SystemTime::now() - Duration::from_secs(60 * 60 * 24);
/// # } /// headers.set(LastModified(modified.into()));
/// ``` /// ```
(LastModified, "Last-Modified") => [HttpDate] (LastModified, "Last-Modified") => [HttpDate]

54
src/header/common/retry_after.rs
View File

@@ -35,11 +35,11 @@
// Version 2.0, January 2004 // Version 2.0, January 2004
// http://www.apache.org/licenses/ // http://www.apache.org/licenses/
use std::fmt;
use std::time::Duration;
use header::{Header, Raw}; use header::{Header, Raw};
use header::shared::HttpDate; use header::shared::HttpDate;
use time;
use time::{Duration, Tm};
use std::fmt;
/// The `Retry-After` header. /// The `Retry-After` header.
/// ///
@@ -53,33 +53,23 @@ use std::fmt;
/// ///
/// # Examples /// # Examples
/// ``` /// ```
/// # extern crate hyper; /// use std::time::Duration;
/// # extern crate time;
/// # fn main() {
/// // extern crate time;
/// use time::{Duration};
/// use hyper::header::{Headers, RetryAfter}; /// use hyper::header::{Headers, RetryAfter};
/// ///
/// let mut headers = Headers::new(); /// let mut headers = Headers::new();
/// headers.set( /// headers.set(
/// RetryAfter::Delay(Duration::seconds(300)) /// RetryAfter::Delay(Duration::from_secs(300))
/// ); /// );
/// # }
/// ``` /// ```
/// ``` /// ```
/// # extern crate hyper; /// use std::time::{SystemTime, Duration};
/// # extern crate time;
/// # fn main() {
/// // extern crate time;
/// use time;
/// use time::{Duration};
/// use hyper::header::{Headers, RetryAfter}; /// use hyper::header::{Headers, RetryAfter};
/// ///
/// let mut headers = Headers::new(); /// let mut headers = Headers::new();
/// let date = SystemTime::now() + Duration::from_secs(300);
/// headers.set( /// headers.set(
/// RetryAfter::DateTime(time::now_utc() + Duration::seconds(300)) /// RetryAfter::DateTime(date.into())
/// ); /// );
/// # }
/// ``` /// ```
/// Retry-After header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-7.1.3) /// Retry-After header, defined in [RFC7231](http://tools.ietf.org/html/rfc7231#section-7.1.3)
@@ -91,7 +81,7 @@ pub enum RetryAfter {
Delay(Duration), Delay(Duration),
/// Retry after the given DateTime /// Retry after the given DateTime
DateTime(Tm), DateTime(HttpDate),
} }
impl Header for RetryAfter { impl Header for RetryAfter {
@@ -108,11 +98,11 @@ impl Header for RetryAfter {
}; };
if let Ok(datetime) = utf8_str.parse::<HttpDate>() { if let Ok(datetime) = utf8_str.parse::<HttpDate>() {
return Ok(RetryAfter::DateTime(datetime.0)) return Ok(RetryAfter::DateTime(datetime))
} }
if let Ok(seconds) = utf8_str.parse::<i64>() { if let Ok(seconds) = utf8_str.parse::<u64>() {
return Ok(RetryAfter::Delay(Duration::seconds(seconds))); return Ok(RetryAfter::Delay(Duration::from_secs(seconds)));
} }
Err(::Error::Header) Err(::Error::Header)
@@ -130,16 +120,10 @@ impl fmt::Display for RetryAfter {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self { match *self {
RetryAfter::Delay(ref duration) => { RetryAfter::Delay(ref duration) => {
write!(f, "{}", duration.num_seconds()) write!(f, "{}", duration.as_secs())
}, },
RetryAfter::DateTime(ref datetime) => { RetryAfter::DateTime(ref datetime) => {
// According to RFC7231, the sender of an HTTP-date must use the RFC1123 format. fmt::Display::fmt(datetime, f)
// http://tools.ietf.org/html/rfc7231#section-7.1.1.1
if let Ok(date_string) = time::strftime("%a, %d %b %Y %T GMT", datetime) {
write!(f, "{}", date_string)
} else {
Err(fmt::Error::default())
}
} }
} }
} }
@@ -147,9 +131,9 @@ impl fmt::Display for RetryAfter {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::time::Duration;
use header::Header; use header::Header;
use header::shared::HttpDate; use header::shared::HttpDate;
use time::{Duration};
use super::RetryAfter; use super::RetryAfter;
@@ -162,7 +146,7 @@ mod tests {
fn parse_delay() { fn parse_delay() {
let retry_after = RetryAfter::parse_header(&vec![b"1234".to_vec()].into()).unwrap(); let retry_after = RetryAfter::parse_header(&vec![b"1234".to_vec()].into()).unwrap();
assert_eq!(RetryAfter::Delay(Duration::seconds(1234)), retry_after); assert_eq!(RetryAfter::Delay(Duration::from_secs(1234)), retry_after);
} }
macro_rules! test_retry_after_datetime { macro_rules! test_retry_after_datetime {
@@ -172,7 +156,7 @@ mod tests {
let dt = "Sun, 06 Nov 1994 08:49:37 GMT".parse::<HttpDate>().unwrap(); let dt = "Sun, 06 Nov 1994 08:49:37 GMT".parse::<HttpDate>().unwrap();
let retry_after = RetryAfter::parse_header(&vec![$bytes.to_vec()].into()).expect("parse_header ok"); let retry_after = RetryAfter::parse_header(&vec![$bytes.to_vec()].into()).expect("parse_header ok");
assert_eq!(RetryAfter::DateTime(dt.0), retry_after); assert_eq!(RetryAfter::DateTime(dt), retry_after);
} }
} }
} }
@@ -184,7 +168,7 @@ mod tests {
#[test] #[test]
fn hyper_headers_from_raw_delay() { fn hyper_headers_from_raw_delay() {
let retry_after = RetryAfter::parse_header(&b"300".to_vec().into()).unwrap(); let retry_after = RetryAfter::parse_header(&b"300".to_vec().into()).unwrap();
assert_eq!(retry_after, RetryAfter::Delay(Duration::seconds(300))); assert_eq!(retry_after, RetryAfter::Delay(Duration::from_secs(300)));
} }
#[test] #[test]
@@ -192,6 +176,6 @@ mod tests {
let retry_after = RetryAfter::parse_header(&b"Sun, 06 Nov 1994 08:49:37 GMT".to_vec().into()).unwrap(); let retry_after = RetryAfter::parse_header(&b"Sun, 06 Nov 1994 08:49:37 GMT".to_vec().into()).unwrap();
let expected = "Sun, 06 Nov 1994 08:49:37 GMT".parse::<HttpDate>().unwrap(); let expected = "Sun, 06 Nov 1994 08:49:37 GMT".parse::<HttpDate>().unwrap();
assert_eq!(retry_after, RetryAfter::DateTime(expected.0)); assert_eq!(retry_after, RetryAfter::DateTime(expected));
} }
} }

15
src/header/common/warning.rs
View File

@@ -33,7 +33,7 @@ use header::parsing::from_one_raw_str;
/// # Examples /// # Examples
/// ``` /// ```
/// use hyper::header::{Headers, Warning}; /// use hyper::header::{Headers, Warning};
/// ///
/// let mut headers = Headers::new(); /// let mut headers = Headers::new();
/// headers.set( /// headers.set(
/// Warning{ /// Warning{
@@ -46,7 +46,7 @@ use header::parsing::from_one_raw_str;
/// ``` /// ```
/// ``` /// ```
/// use hyper::header::{Headers, HttpDate, Warning}; /// use hyper::header::{Headers, HttpDate, Warning};
/// ///
/// let mut headers = Headers::new(); /// let mut headers = Headers::new();
/// headers.set( /// headers.set(
/// Warning{ /// Warning{
@@ -58,21 +58,18 @@ use header::parsing::from_one_raw_str;
/// ); /// );
/// ``` /// ```
/// ``` /// ```
/// # extern crate hyper; /// use std::time::SystemTime;
/// # extern crate time; /// use hyper::header::{Headers, Warning};
/// # fn main() { ///
/// use hyper::header::{Headers, HttpDate, Warning};
///
/// let mut headers = Headers::new(); /// let mut headers = Headers::new();
/// headers.set( /// headers.set(
/// Warning{ /// Warning{
/// code: 199, /// code: 199,
/// agent: "api.hyper.rs".to_owned(), /// agent: "api.hyper.rs".to_owned(),
/// text: "Deprecated".to_owned(), /// text: "Deprecated".to_owned(),
/// date: Some(HttpDate(time::now())) /// date: Some(SystemTime::now().into())
/// } /// }
/// ); /// );
/// # }
/// ``` /// ```
#[derive(PartialEq, Clone, Debug)] #[derive(PartialEq, Clone, Debug)]
pub struct Warning { pub struct Warning {

34
src/header/shared/httpdate.rs
View File

@@ -1,10 +1,10 @@
use std::str::FromStr;
use std::fmt::{self, Display}; use std::fmt::{self, Display};
use std::str::FromStr;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use time; use time;
/// A `time::Time` with HTTP formatting and parsing /// A timestamp with HTTP formatting and parsing
///
// Prior to 1995, there were three different formats commonly used by // Prior to 1995, there were three different formats commonly used by
// servers to communicate timestamps. For compatibility with old // servers to communicate timestamps. For compatibility with old
// implementations, all three are defined here. The preferred format is // implementations, all three are defined here. The preferred format is
@@ -28,7 +28,7 @@ use time;
// HTTP-date, the sender MUST generate those timestamps in the // HTTP-date, the sender MUST generate those timestamps in the
// IMF-fixdate format. // IMF-fixdate format.
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct HttpDate(pub time::Tm); pub struct HttpDate(time::Tm);
impl FromStr for HttpDate { impl FromStr for HttpDate {
type Err = ::Error; type Err = ::Error;
@@ -50,6 +50,32 @@ impl Display for HttpDate {
} }
} }
impl From<SystemTime> for HttpDate {
fn from(sys: SystemTime) -> HttpDate {
let tmspec = match sys.duration_since(UNIX_EPOCH) {
Ok(dur) => {
time::Timespec::new(dur.as_secs() as i64, dur.subsec_nanos() as i32)
},
Err(err) => {
let neg = err.duration();
time::Timespec::new(-(neg.as_secs() as i64), -(neg.subsec_nanos() as i32))
},
};
HttpDate(time::at_utc(tmspec))
}
}
impl From<HttpDate> for SystemTime {
fn from(date: HttpDate) -> SystemTime {
let spec = date.0.to_timespec();
if spec.sec >= 0 {
UNIX_EPOCH + Duration::new(spec.sec as u64, spec.nsec as u32)
} else {
UNIX_EPOCH - Duration::new(spec.sec as u64, spec.nsec as u32)
}
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use time::Tm; use time::Tm;

3
src/http/h1/parse.rs
View File

@@ -1,5 +1,6 @@
use std::borrow::Cow; use std::borrow::Cow;
use std::fmt::{self, Write}; use std::fmt::{self, Write};
use std::time::SystemTime;
use httparse; use httparse;
use bytes::{BytesMut, Bytes}; use bytes::{BytesMut, Bytes};
@@ -94,7 +95,7 @@ impl Http1Transaction for ServerTransaction {
trace!("writing head: {:?}", head); trace!("writing head: {:?}", head);
if !head.headers.has::<header::Date>() { if !head.headers.has::<header::Date>() {
head.headers.set(header::Date(header::HttpDate(::time::now_utc()))); head.headers.set(header::Date(SystemTime::now().into()));
} }
let mut is_chunked = true; let mut is_chunked = true;