header name constants changed from &str to HeaderName (#839)

Author: ctaggart

sdk/core/src/constants.rs

@@ -17,15 +17,20 @@ pub mod resource_manager_endpoint {
 ///
 /// <https://developer.mozilla.org/docs/Web/HTTP/Headers/Content-Type>
 pub mod content_type {
+    use crate::headers::HeaderValue;
+
     // Form content types
     // https://www.w3.org/TR/html401/interact/forms.html#h-17.13.4
 
-    pub const MULTIPART_FORM_DATA: &str = "multipart/form-data";
-    pub const APPLICATION_X_WWW_FORM_URLENCODED: &str = "application/x-www-form-urlencoded";
+    pub const MULTIPART_FORM_DATA: HeaderValue = HeaderValue::from_static("multipart/form-data");
+    pub const APPLICATION_X_WWW_FORM_URLENCODED: HeaderValue =
+        HeaderValue::from_static("application/x-www-form-urlencoded");
 
-    pub const APPLICATION_XML: &str = "application/xml";
-    pub const APPLICATION_JSON: &str = "application/json";
-    pub const APPLICATION_OCTET_STREAM: &str = "application/octet-stream";
+    pub const APPLICATION_XML: HeaderValue = HeaderValue::from_static("application/xml");
+    pub const APPLICATION_JSON: HeaderValue = HeaderValue::from_static("application/json");
+    pub const APPLICATION_OCTET_STREAM: HeaderValue =
+        HeaderValue::from_static("application/octet-stream");
+    pub const TEXT_PLAIN: HeaderValue = HeaderValue::from_static("text/plain");
 }
 
 /// Constants related to the Content-Type header

sdk/core/src/error/http_error.rs

@@ -1,4 +1,4 @@
-use crate::Response;
+use crate::{headers, Response};
 use bytes::Bytes;
 use std::collections::HashMap;
 
@@ -72,7 +72,7 @@ impl std::error::Error for HttpError {}
 ///
 /// For more info, see [here](https://github.com/microsoft/api-guidelines/blob/vNext/azure/Guidelines.md#handling-errors)
 fn get_error_code_from_header(response: &Response) -> Option<String> {
-    response.headers().get_as_string("x-ms-error-code")
+    response.headers().get_as_string(&headers::ERROR_CODE)
 }
 
 /// Gets the error code if it's present in the body

sdk/core/src/error/hyperium_http.rs

@@ -1,6 +1,4 @@
 use super::{Error, ErrorKind};
-
-use http::header::{InvalidHeaderName, InvalidHeaderValue};
 use http::method::InvalidMethod;
 use http::status::InvalidStatusCode;
 use http::uri::{InvalidUri, InvalidUriParts};
@@ -11,18 +9,6 @@ impl From<http::Error> for super::Error {
     }
 }
 
-impl From<InvalidHeaderName> for super::Error {
-    fn from(err: InvalidHeaderName) -> super::Error {
-        Error::new(ErrorKind::DataConversion, err)
-    }
-}
-
-impl From<InvalidHeaderValue> for super::Error {
-    fn from(err: InvalidHeaderValue) -> super::Error {
-        Error::new(ErrorKind::DataConversion, err)
-    }
-}
-
 impl From<InvalidMethod> for super::Error {
     fn from(err: InvalidMethod) -> super::Error {
         Error::new(ErrorKind::DataConversion, err)

sdk/core/src/headers/mod.rs

@@ -2,31 +2,29 @@ use super::*;
 use crate::error::{Error, ErrorKind};
 use crate::request_options::LeaseId;
 use crate::{RequestId, SessionToken};
-
 use chrono::{DateTime, FixedOffset, Utc};
-use http::header::{DATE, ETAG, LAST_MODIFIED, SERVER};
 use std::str::FromStr;
 
 pub fn get_option_str_from_headers<'a>(
     headers: &'a Headers,
-    key: &str,
+    key: &HeaderName,
 ) -> crate::Result<Option<&'a str>> {
-    let h = match headers.get(key.to_owned()) {
+    let h = match headers.get(key) {
         Some(h) => h,
         None => return Ok(None),
     };
     Ok(Some(h.as_str()))
 }
 
-pub fn get_str_from_headers<'a>(headers: &'a Headers, key: &str) -> crate::Result<&'a str> {
+pub fn get_str_from_headers<'a>(headers: &'a Headers, key: &HeaderName) -> crate::Result<&'a str> {
     get_option_str_from_headers(headers, key)?.ok_or_else(|| {
         Error::with_message(ErrorKind::DataConversion, || {
-            format!("could not find '{key}' in headers")
+            format!("could not find '{key:?}' in headers")
         })
     })
 }
 
-pub fn get_option_from_headers<T>(headers: &Headers, key: &str) -> crate::Result<Option<T>>
+pub fn get_option_from_headers<T>(headers: &Headers, key: &HeaderName) -> crate::Result<Option<T>>
 where
     T: std::str::FromStr + 'static,
     T::Err: std::error::Error + Send + Sync,
@@ -41,15 +39,15 @@ where
             ErrorKind::DataConversion,
             e,
             format!(
-                "failed to parse header '{}' as {:?}",
+                "failed to parse header '{:?}' as {:?}",
                 key,
                 std::any::TypeId::of::<T>()
             ),
         )
     })?))
 }
 
-pub fn get_from_headers<T>(headers: &Headers, key: &str) -> crate::Result<T>
+pub fn get_from_headers<T>(headers: &Headers, key: &HeaderName) -> crate::Result<T>
 where
     T: std::str::FromStr + 'static,
     T::Err: std::error::Error + Send + Sync,
@@ -59,7 +57,7 @@ where
             ErrorKind::DataConversion,
             e,
             format!(
-                "failed to parse header '{}' as {:?}",
+                "failed to parse header '{:?}' as {:?}",
                 key,
                 std::any::TypeId::of::<T>()
             ),
@@ -104,36 +102,36 @@ where
 }
 
 pub fn lease_id_from_headers(headers: &Headers) -> crate::Result<LeaseId> {
-    get_from_headers(headers, LEASE_ID)
+    get_from_headers(headers, &LEASE_ID)
 }
 
 pub fn request_id_from_headers(headers: &Headers) -> crate::Result<RequestId> {
-    get_from_headers(headers, REQUEST_ID)
+    get_from_headers(headers, &REQUEST_ID)
 }
 
 pub fn client_request_id_from_headers_optional(headers: &Headers) -> Option<String> {
-    get_option_from_headers(headers, CLIENT_REQUEST_ID)
+    get_option_from_headers(headers, &CLIENT_REQUEST_ID)
         .ok()
         .flatten()
 }
 
 pub fn last_modified_from_headers_optional(
     headers: &Headers,
 ) -> crate::Result<Option<DateTime<Utc>>> {
-    get_option_from_headers(headers, LAST_MODIFIED.as_str())
+    get_option_from_headers(headers, &LAST_MODIFIED)
 }
 
 pub fn date_from_headers(headers: &Headers) -> crate::Result<DateTime<Utc>> {
-    rfc2822_from_headers_mandatory(headers, DATE.as_str())
+    rfc2822_from_headers_mandatory(headers, &DATE)
 }
 
 pub fn last_modified_from_headers(headers: &Headers) -> crate::Result<DateTime<Utc>> {
-    rfc2822_from_headers_mandatory(headers, LAST_MODIFIED.as_str())
+    rfc2822_from_headers_mandatory(headers, &LAST_MODIFIED)
 }
 
 pub fn rfc2822_from_headers_mandatory(
     headers: &Headers,
-    header_name: &str,
+    header_name: &HeaderName,
 ) -> crate::Result<DateTime<Utc>> {
     let date = get_str_from_headers(headers, header_name)?;
     utc_date_from_rfc2822(date)
@@ -147,63 +145,63 @@ pub fn utc_date_from_rfc2822(date: &str) -> crate::Result<DateTime<Utc>> {
 pub fn continuation_token_from_headers_optional(
     headers: &Headers,
 ) -> crate::Result<Option<String>> {
-    Ok(get_option_str_from_headers(headers, CONTINUATION)?.map(String::from))
+    Ok(get_option_str_from_headers(headers, &CONTINUATION)?.map(String::from))
 }
 
 pub fn sku_name_from_headers(headers: &Headers) -> crate::Result<String> {
-    Ok(get_str_from_headers(headers, SKU_NAME)?.to_owned())
+    Ok(get_str_from_headers(headers, &SKU_NAME)?.to_owned())
 }
 
 pub fn account_kind_from_headers(headers: &Headers) -> crate::Result<String> {
-    Ok(get_str_from_headers(headers, ACCOUNT_KIND)?.to_owned())
+    Ok(get_str_from_headers(headers, &ACCOUNT_KIND)?.to_owned())
 }
 
 pub fn etag_from_headers_optional(headers: &Headers) -> crate::Result<Option<String>> {
-    Ok(get_option_str_from_headers(headers, ETAG.as_str())?.map(String::from))
+    Ok(get_option_str_from_headers(headers, &ETAG)?.map(String::from))
 }
 
 pub fn etag_from_headers(headers: &Headers) -> crate::Result<String> {
-    Ok(get_str_from_headers(headers, ETAG.as_str())?.to_owned())
+    Ok(get_str_from_headers(headers, &ETAG)?.to_owned())
 }
 
 pub fn lease_time_from_headers(headers: &Headers) -> crate::Result<u8> {
-    get_from_headers(headers, LEASE_TIME)
+    get_from_headers(headers, &LEASE_TIME)
 }
 
 #[cfg(not(feature = "azurite_workaround"))]
 pub fn delete_type_permanent_from_headers(headers: &Headers) -> crate::Result<bool> {
-    get_from_headers(headers, DELETE_TYPE_PERMANENT)
+    get_from_headers(headers, &DELETE_TYPE_PERMANENT)
 }
 
 #[cfg(feature = "azurite_workaround")]
 pub fn delete_type_permanent_from_headers(headers: &Headers) -> crate::Result<Option<bool>> {
-    get_option_from_headers(headers, DELETE_TYPE_PERMANENT)
+    get_option_from_headers(headers, &DELETE_TYPE_PERMANENT)
 }
 
 pub fn sequence_number_from_headers(headers: &Headers) -> crate::Result<u64> {
-    get_from_headers(headers, BLOB_SEQUENCE_NUMBER)
+    get_from_headers(headers, &BLOB_SEQUENCE_NUMBER)
 }
 
 pub fn session_token_from_headers(headers: &Headers) -> crate::Result<SessionToken> {
-    get_str_from_headers(headers, SESSION_TOKEN).map(ToOwned::to_owned)
+    get_str_from_headers(headers, &SESSION_TOKEN).map(ToOwned::to_owned)
 }
 
 pub fn server_from_headers(headers: &Headers) -> crate::Result<&str> {
-    get_str_from_headers(headers, SERVER.as_str())
+    get_str_from_headers(headers, &SERVER)
 }
 
 pub fn version_from_headers(headers: &Headers) -> crate::Result<&str> {
-    get_str_from_headers(headers, VERSION)
+    get_str_from_headers(headers, &VERSION)
 }
 
 pub fn request_server_encrypted_from_headers(headers: &Headers) -> crate::Result<bool> {
-    get_from_headers(headers, REQUEST_SERVER_ENCRYPTED)
+    get_from_headers(headers, &REQUEST_SERVER_ENCRYPTED)
 }
 
 pub fn content_type_from_headers(headers: &Headers) -> crate::Result<&str> {
-    get_str_from_headers(headers, http::header::CONTENT_TYPE.as_str())
+    get_str_from_headers(headers, &CONTENT_TYPE)
 }
 
 pub fn item_count_from_headers(headers: &Headers) -> crate::Result<u32> {
-    get_from_headers(headers, ITEM_COUNT)
+    get_from_headers(headers, &ITEM_COUNT)
 }

sdk/core/src/headers/utilities.rs

@@ -53,7 +53,7 @@ impl HttpClient for reqwest::Client {
         let url = request.url().clone();
         let mut reqwest_request = self.request(request.method().clone(), url);
         for (name, value) in request.headers().iter() {
-            reqwest_request = reqwest_request.header(name, value);
+            reqwest_request = reqwest_request.header(name.as_str(), value.as_str());
         }
 
         let body = request.body().clone();

sdk/core/src/http_client.rs

@@ -1,9 +1,13 @@
 use bytes::Bytes;
-use http::{header, StatusCode};
+use http::StatusCode;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
-use crate::{collect_pinned_stream, error, headers::Headers, BytesStream, Response};
+use crate::{
+    collect_pinned_stream, error,
+    headers::{HeaderName, HeaderValue, Headers},
+    BytesStream, Response,
+};
 
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct MockResponse {
@@ -63,8 +67,8 @@ impl<'de> Deserialize<'de> for MockResponse {
         let r = SerializedMockResponse::deserialize(deserializer)?;
         let mut headers = Headers::new();
         for (n, v) in r.headers.iter() {
-            let name = header::HeaderName::from_lowercase(n.as_bytes()).map_err(Error::custom)?;
-            let value = header::HeaderValue::from_str(&v).map_err(Error::custom)?;
+            let name = HeaderName::from(n.to_owned());
+            let value = HeaderValue::from(v.to_owned());
             headers.insert(name, value);
         }
         let body = Bytes::from(base64::decode(r.body).map_err(Error::custom)?);

sdk/core/src/mock/mock_response.rs

@@ -57,8 +57,7 @@ impl MockTransaction {
                         "the transaction location '{}' does not exist",
                         path.canonicalize().unwrap_or(path).display()
                     )
-                })
-                .into());
+                }));
             }
         }
 
@@ -81,7 +80,7 @@ fn workspace_root() -> crate::Result<String> {
         )
     })?;
     let value = &output[index + key.len()..];
-    let end = value.find("\"").ok_or_else(|| {
+    let end = value.find('\"').ok_or_else(|| {
         Error::message(
             ErrorKind::MockFramework,
             "workspace_root value was malformed",

sdk/core/src/mock/mock_transaction.rs

@@ -65,8 +65,7 @@ impl Policy for MockTransportPlayerPolicy {
         // check if the passed request matches the one read from disk
         // We will ignore some headers that are bound to change every time
         // We'll probabily want to make the exclusion list dynamic at some point.
-        const SKIPPED_HEADERS: &[&'static str] =
-            &["Date", "x-ms-date", "authorization", "user-agent"];
+        const SKIPPED_HEADERS: &[&str] = &["Date", "x-ms-date", "authorization", "user-agent"];
         let actual_headers = request
             .headers()
             .iter()
@@ -97,14 +96,14 @@ impl Policy for MockTransportPlayerPolicy {
                 .iter()
                 .find(|(h, _)| actual_header_key.as_str() == h.as_str())
                 .ok_or_else(|| Error::with_message(ErrorKind::MockFramework, ||
-                    format!("received request have header {0} but it was not present in the read request",
+                    format!("received request have header '{0}' but it was not present in the read request",
                     actual_header_key.as_str(),
                 )))?;
 
             if actual_header_value != expected_header_value {
                 return Err(Error::with_message(ErrorKind::MockFramework, || {
                     format!(
-                        "request header {0} value is different. Actual: {1}, Expected: {2}",
+                        "request header '{0}' value is different. Actual: {1}, Expected: {2}",
                         actual_header_key.as_str().to_owned(),
                         actual_header_value.as_str().to_owned(),
                         expected_header_value.as_str().to_owned(),
@@ -124,12 +123,12 @@ impl Policy for MockTransportPlayerPolicy {
         }
 
         let actual_body = match request.body() {
-            crate::Body::Bytes(bytes) => &bytes as &[u8],
+            crate::Body::Bytes(bytes) => bytes as &[u8],
             crate::Body::SeekableStream(_) => unimplemented!(),
         };
 
         let expected_body = match expected_request.body() {
-            crate::Body::Bytes(bytes) => &bytes as &[u8],
+            crate::Body::Bytes(bytes) => bytes as &[u8],
             crate::Body::SeekableStream(_) => unimplemented!(),
         };
 

sdk/core/src/mock/player_policy.rs

@@ -32,9 +32,7 @@ impl Policy for CustomHeadersPolicy {
                         header_name,
                         header_value
                     );
-                    request
-                        .headers_mut()
-                        .insert(header_name.clone(), header_value.clone());
+                    request.insert_header(header_name.clone(), header_value.clone());
                 });
         }