diff --git a/sdk/data_tables/src/responses/submit_transaction_response.rs b/sdk/data_tables/src/responses/submit_transaction_response.rs index 8c033cff63..8c0ba9696a 100644 --- a/sdk/data_tables/src/responses/submit_transaction_response.rs +++ b/sdk/data_tables/src/responses/submit_transaction_response.rs @@ -38,7 +38,7 @@ impl TryFrom<&Response> for SubmitTransactionResponse { let mut operation_response = OperationResponse::default(); - for line in change_set_response.lines().into_iter() { + for line in change_set_response.lines() { if line.starts_with("HTTP/1.1") { operation_response.status_code = line .split_whitespace() diff --git a/sdk/storage/src/core/errors.rs b/sdk/storage/src/core/errors.rs index ae7ba69a82..96359ff3b5 100644 --- a/sdk/storage/src/core/errors.rs +++ b/sdk/storage/src/core/errors.rs @@ -81,6 +81,12 @@ impl From for Error { } } +impl From for Error { + fn from(error: azure_core::StreamError) -> Self { + Self::CoreError(azure_core::Error::Stream(error)) + } +} + #[non_exhaustive] #[derive(Debug, PartialEq, thiserror::Error)] pub enum AzurePathParseError { diff --git a/sdk/storage_datalake/examples/data_lake_00_file_system.rs b/sdk/storage_datalake/examples/data_lake_00_file_system.rs index 50d52e313a..06b8e1504b 100644 --- a/sdk/storage_datalake/examples/data_lake_00_file_system.rs +++ b/sdk/storage_datalake/examples/data_lake_00_file_system.rs @@ -1,4 +1,3 @@ -use azure_storage::core::prelude::*; use azure_storage::storage_shared_key_credential::StorageSharedKeyCredential; use azure_storage_datalake::prelude::*; use chrono::Utc; @@ -21,24 +20,22 @@ async fn main() -> Result<(), Box> { println!("creating file system '{}'...", &file_system_name); let create_fs_response = file_system_client .create() - .properties(&fs_properties) - .execute() + .properties(fs_properties.clone()) + .into_future() .await?; println!("create file system response == {:?}\n", create_fs_response); println!("listing file systems..."); - let mut stream = Box::pin( - data_lake_client - .list() - .max_results(NonZeroU32::new(3).unwrap()) - .stream(), - ); + let mut stream = data_lake_client + .list_file_systems() + .max_results(NonZeroU32::new(3).unwrap()) + .into_stream(); while let Some(list_fs_response) = stream.next().await { println!("list file system response == {:?}\n", list_fs_response); } println!("getting file system properties..."); - let get_fs_props_response = file_system_client.get_properties().execute().await?; + let get_fs_props_response = file_system_client.get_properties().into_future().await?; println!( "get file system properties response == {:?}\n", get_fs_props_response @@ -47,8 +44,8 @@ async fn main() -> Result<(), Box> { println!("setting file system properties..."); fs_properties.insert("ModifiedBy", "Iota"); let set_fs_props_response = file_system_client - .set_properties(Some(&fs_properties)) - .execute() + .set_properties(Some(fs_properties)) + .into_future() .await?; println!( "set file system properties response == {:?}\n", @@ -56,14 +53,14 @@ async fn main() -> Result<(), Box> { ); println!("getting file system properties..."); - let get_fs_props_response = file_system_client.get_properties().execute().await?; + let get_fs_props_response = file_system_client.get_properties().into_future().await?; println!( "get file system properties response == {:?}\n", get_fs_props_response ); println!("deleting file system..."); - let delete_fs_response = file_system_client.delete().execute().await?; + let delete_fs_response = file_system_client.delete().into_future().await?; println!("delete file system response == {:?}\n", delete_fs_response); Ok(()) @@ -75,15 +72,7 @@ async fn create_data_lake_client() -> Result Result<(), Box> { .into_file_system_client(file_system_name.to_string()); println!("creating file system '{}'...", &file_system_name); - let create_fs_response = file_system_client.create().execute().await?; + let create_fs_response = file_system_client.create().into_future().await?; println!("create file system response == {:?}\n", create_fs_response); let file_path = "some/path/example-file.txt"; @@ -47,7 +47,7 @@ async fn main() -> Result<(), Box> { println!("delete_file file response == {:?}\n", delete_file_response); println!("deleting file system..."); - let delete_fs_response = file_system_client.delete().execute().await?; + let delete_fs_response = file_system_client.delete().into_future().await?; println!("delete file system response == {:?}\n", delete_fs_response); Ok(()) @@ -59,15 +59,7 @@ async fn create_data_lake_client() -> Result Result<(), Box> { .into_file_system_client(file_system_name.to_string()); println!("creating file system '{}'...", &file_system_name); - let create_fs_response = file_system_client.create().execute().await?; + let create_fs_response = file_system_client.create().into_future().await?; println!("create file system response == {:?}\n", create_fs_response); let file_path = "some/path/example-file.txt"; @@ -70,7 +70,7 @@ async fn main() -> Result<(), Box> { println!("flush file response == {:?}\n", flush_file_response); println!("deleting file system..."); - let delete_fs_response = file_system_client.delete().execute().await?; + let delete_fs_response = file_system_client.delete().into_future().await?; println!("delete file system response == {:?}\n", delete_fs_response); Ok(()) @@ -82,15 +82,7 @@ async fn create_data_lake_client() -> Result Result<(), Box> { .into_file_system_client(file_system_name.to_string()); println!("creating file system '{}'...", &file_system_name); - let create_fs_response = file_system_client.create().execute().await?; + let create_fs_response = file_system_client.create().into_future().await?; println!("create file system response == {:?}\n", create_fs_response); let file_path1 = "some/path/example-file1.txt"; @@ -56,7 +56,7 @@ async fn main() -> Result<(), Box> { println!("rename file response == {:?}\n", rename_file_response); println!("deleting file system..."); - let delete_fs_response = file_system_client.delete().execute().await?; + let delete_fs_response = file_system_client.delete().into_future().await?; println!("delete file system response == {:?}\n", delete_fs_response); Ok(()) @@ -68,15 +68,7 @@ async fn create_data_lake_client() -> Result, custom_dns_suffix: Option, url: String, // TODO: Use CloudLocation similar to CosmosClient + pub(crate) context: Context, } impl DataLakeClient { pub(crate) fn new_with_options( - storage_client: Arc, credential: StorageSharedKeyCredential, custom_dns_suffix: Option, options: ClientOptions, @@ -40,8 +37,8 @@ impl DataLakeClient { let per_call_policies = Vec::new(); let auth_policy: Arc = // TODO: Allow caller to choose auth policy, follow pattern of other clients - // Arc::new(BearerTokenAuthorizationPolicy::new(bearer_token)); - Arc::new(SharedKeyAuthorizationPolicy::new(url.to_owned(), credential)); + // Arc::new(BearerTokenAuthorizationPolicy::new(bearer_token)); + Arc::new(SharedKeyAuthorizationPolicy::new(url.to_owned(), credential)); // take care of adding the AuthorizationPolicy as **last** retry policy. // Policies can change the url and/or the headers and the AuthorizationPolicy @@ -56,59 +53,55 @@ impl DataLakeClient { per_retry_policies, ); + let mut context = Context::new(); + context.insert(ServiceType::Blob); + Self { pipeline, - storage_client, custom_dns_suffix, url, + context, } } - pub fn new( - storage_client: Arc, - credential: StorageSharedKeyCredential, - custom_dns_suffix: Option, - ) -> DataLakeClient { - Self::new_with_options( - storage_client, - credential, - custom_dns_suffix, - ClientOptions::default(), - ) + pub fn new(credential: StorageSharedKeyCredential, custom_dns_suffix: Option) -> Self { + Self::new_with_options(credential, custom_dns_suffix, ClientOptions::default()) } pub fn custom_dns_suffix(&self) -> Option<&str> { self.custom_dns_suffix.as_deref() } - pub(crate) fn http_client(&self) -> &dyn HttpClient { - self.storage_client.storage_account_client().http_client() - } - pub(crate) fn url(&self) -> &str { &self.url } - pub fn list(&self) -> ListFileSystemsBuilder { - ListFileSystemsBuilder::new(self) + pub fn list_file_systems(&self) -> ListFileSystems { + ListFileSystems::new(self.clone(), Some(self.context.clone())) } pub fn into_file_system_client(self, file_system_name: String) -> FileSystemClient { FileSystemClient::new(self, file_system_name) } - pub(crate) fn prepare_request( + pub(crate) fn prepare_request_pipeline( &self, - url: &str, - method: &Method, - http_header_adder: &dyn Fn(Builder) -> Builder, - request_body: Option, - ) -> crate::Result<(Request, url::Url)> { - self.storage_client - .prepare_request(url, method, http_header_adder, request_body) + uri: &str, + http_method: http::Method, + ) -> azure_core::Request { + Builder::new() + .method(http_method) + .uri(uri) + .body(bytes::Bytes::new()) + .unwrap() + .into() } - pub(crate) fn pipeline(&self) -> &Pipeline { + pub fn pipeline(&self) -> &Pipeline { &self.pipeline } + + pub fn http_client(&self) -> &dyn HttpClient { + self.pipeline.http_client() + } } diff --git a/sdk/storage_datalake/src/clients/file_system_client.rs b/sdk/storage_datalake/src/clients/file_system_client.rs index 0e045d1a77..9b6ce6726f 100644 --- a/sdk/storage_datalake/src/clients/file_system_client.rs +++ b/sdk/storage_datalake/src/clients/file_system_client.rs @@ -1,9 +1,8 @@ use crate::operations::*; -use crate::requests::*; use crate::{clients::DataLakeClient, Properties}; use azure_core::prelude::IfMatchCondition; +use azure_core::Context; use azure_core::Pipeline; -use azure_core::{Context, HttpClient}; use bytes::Bytes; use url::Url; @@ -12,6 +11,7 @@ pub struct FileSystemClient { data_lake_client: DataLakeClient, name: String, url: Url, + pub(crate) context: Context, } impl FileSystemClient { @@ -22,30 +22,30 @@ impl FileSystemClient { .unwrap() .push(&name); + let context = data_lake_client.context.clone(); + Self { data_lake_client, name, url, + context, } } pub fn create(&self) -> CreateFileSystemBuilder { - CreateFileSystemBuilder::new(self) + CreateFileSystemBuilder::new(self.clone()) } pub fn delete(&self) -> DeleteFileSystemBuilder { - DeleteFileSystemBuilder::new(self) + DeleteFileSystemBuilder::new(self.clone()) } pub fn get_properties(&self) -> GetFileSystemPropertiesBuilder { - GetFileSystemPropertiesBuilder::new(self) + GetFileSystemPropertiesBuilder::new(self.clone()) } - pub fn set_properties<'a>( - &'a self, - properties: Option<&'a Properties<'a, 'a>>, - ) -> SetFileSystemPropertiesBuilder { - SetFileSystemPropertiesBuilder::new(self, properties) + pub fn set_properties(&self, properties: Option) -> SetFileSystemPropertiesBuilder { + SetFileSystemPropertiesBuilder::new(self.clone(), properties) } pub async fn create_file( @@ -157,24 +157,17 @@ impl FileSystemClient { Ok(FileFlushResponse::try_from(response).await?) } - pub(crate) fn http_client(&self) -> &dyn HttpClient { - self.data_lake_client.http_client() - } - pub(crate) fn url(&self) -> &Url { &self.url } - /// Note: This is part of the old (non-pipeline) architecture. Eventually this method will disappear. - pub(crate) fn prepare_request( + pub(crate) fn prepare_request_pipeline( &self, - url: &str, - method: &http::method::Method, - http_header_adder: &dyn Fn(http::request::Builder) -> http::request::Builder, - request_body: Option, - ) -> crate::Result<(http::request::Request, url::Url)> { + uri: &str, + http_method: http::Method, + ) -> azure_core::Request { self.data_lake_client - .prepare_request(url, method, http_header_adder, request_body) + .prepare_request_pipeline(uri, http_method) } pub(crate) fn prepare_file_create_request(&self, file_path: &str) -> azure_core::Request { diff --git a/sdk/storage_datalake/src/lib.rs b/sdk/storage_datalake/src/lib.rs index 62b38f6801..f0bd5ff88f 100644 --- a/sdk/storage_datalake/src/lib.rs +++ b/sdk/storage_datalake/src/lib.rs @@ -11,8 +11,6 @@ mod bearer_token_authorization_policy; pub mod clients; mod file_system; pub mod operations; -pub mod requests; -pub mod responses; mod shared_key_authorization_policy; pub use file_system::FileSystem; mod properties; diff --git a/sdk/storage_datalake/src/operations/file_system_create.rs b/sdk/storage_datalake/src/operations/file_system_create.rs new file mode 100644 index 0000000000..4cc411625f --- /dev/null +++ b/sdk/storage_datalake/src/operations/file_system_create.rs @@ -0,0 +1,92 @@ +use crate::clients::FileSystemClient; +use crate::util::*; +use crate::Properties; +use azure_core::prelude::*; +use azure_core::{ + headers::{add_mandatory_header2, add_optional_header2}, + AppendToUrlQuery, Response as HttpResponse, +}; +use azure_core::{ + headers::{etag_from_headers, last_modified_from_headers}, + Etag, +}; +use azure_storage::core::headers::CommonStorageResponseHeaders; +use chrono::{DateTime, Utc}; +use std::convert::TryInto; + +/// A future of a create file system response +type CreateFileSystem = + futures::future::BoxFuture<'static, crate::Result>; + +#[derive(Debug, Clone)] +pub struct CreateFileSystemBuilder { + client: FileSystemClient, + client_request_id: Option, + timeout: Option, + properties: Option, +} + +impl CreateFileSystemBuilder { + pub(crate) fn new(client: FileSystemClient) -> Self { + Self { + client, + client_request_id: None, + timeout: None, + properties: None, + } + } + + setters! { + client_request_id: ClientRequestId => Some(client_request_id), + timeout: Timeout => Some(timeout), + properties: Properties => Some(properties), + } + + pub fn into_future(self) -> CreateFileSystem { + let this = self.clone(); + let ctx = self.client.context.clone(); + + Box::pin(async move { + let mut url = this.client.url().clone(); + url.query_pairs_mut().append_pair("resource", "filesystem"); + self.timeout.append_to_url_query(&mut url); + + let mut request = this + .client + .prepare_request_pipeline(url.as_str(), http::Method::PUT); + + add_optional_header2(&this.client_request_id, &mut request)?; + add_optional_header2(&this.properties, &mut request)?; + add_mandatory_header2(&ContentLength::new(0), &mut request)?; + + let response = self + .client + .pipeline() + .send(&mut ctx.clone(), &mut request) + .await?; + + CreateFileSystemResponse::try_from(response).await + }) + } +} + +#[derive(Debug, Clone)] +pub struct CreateFileSystemResponse { + pub common_storage_response_headers: CommonStorageResponseHeaders, + pub etag: Etag, + pub last_modified: DateTime, + pub namespace_enabled: bool, +} + +impl CreateFileSystemResponse { + pub async fn try_from(response: HttpResponse) -> crate::Result { + let (_status_code, headers, _pinned_stream) = response.deconstruct(); + + Ok(Self { + common_storage_response_headers: (&headers).try_into()?, + etag: Etag::from(etag_from_headers(&headers)?), + last_modified: last_modified_from_headers(&headers)?, + namespace_enabled: namespace_enabled_from_headers(&headers)?, + }) + } +} diff --git a/sdk/storage_datalake/src/operations/file_system_delete.rs b/sdk/storage_datalake/src/operations/file_system_delete.rs new file mode 100644 index 0000000000..02ba103f5c --- /dev/null +++ b/sdk/storage_datalake/src/operations/file_system_delete.rs @@ -0,0 +1,79 @@ +use crate::clients::FileSystemClient; +use azure_core::prelude::*; +use azure_core::{ + headers::{add_mandatory_header2, add_optional_header2}, + AppendToUrlQuery, Response as HttpResponse, +}; +use azure_storage::core::headers::CommonStorageResponseHeaders; +use std::convert::TryInto; + +/// A future of a create file system response +type DeleteFileSystem = + futures::future::BoxFuture<'static, crate::Result>; + +#[derive(Debug, Clone)] +pub struct DeleteFileSystemBuilder { + client: FileSystemClient, + if_modified_since_condition: Option, + client_request_id: Option, + timeout: Option, +} + +impl DeleteFileSystemBuilder { + pub(crate) fn new(client: FileSystemClient) -> Self { + Self { + client, + if_modified_since_condition: None, + client_request_id: None, + timeout: None, + } + } + + setters! { + if_modified_since_condition: IfModifiedSinceCondition => Some(if_modified_since_condition), + client_request_id: ClientRequestId => Some(client_request_id), + timeout: Timeout => Some(timeout), + } + + pub fn into_future(self) -> DeleteFileSystem { + let this = self.clone(); + let ctx = self.client.context.clone(); + + Box::pin(async move { + let mut url = this.client.url().clone(); + self.timeout.append_to_url_query(&mut url); + url.query_pairs_mut().append_pair("resource", "filesystem"); + + let mut request = this + .client + .prepare_request_pipeline(url.as_str(), http::Method::DELETE); + + add_optional_header2(&this.client_request_id, &mut request)?; + add_optional_header2(&this.if_modified_since_condition, &mut request)?; + add_mandatory_header2(&ContentLength::new(0), &mut request)?; + + let response = self + .client + .pipeline() + .send(&mut ctx.clone(), &mut request) + .await?; + + DeleteFileSystemResponse::try_from(response).await + }) + } +} + +#[derive(Debug, Clone)] +pub struct DeleteFileSystemResponse { + pub common_storage_response_headers: CommonStorageResponseHeaders, +} + +impl DeleteFileSystemResponse { + pub async fn try_from(response: HttpResponse) -> crate::Result { + let (_status_code, headers, _pinned_stream) = response.deconstruct(); + + Ok(Self { + common_storage_response_headers: (&headers).try_into()?, + }) + } +} diff --git a/sdk/storage_datalake/src/operations/file_system_get_properties.rs b/sdk/storage_datalake/src/operations/file_system_get_properties.rs new file mode 100644 index 0000000000..c13b8abcc5 --- /dev/null +++ b/sdk/storage_datalake/src/operations/file_system_get_properties.rs @@ -0,0 +1,89 @@ +use crate::clients::FileSystemClient; +use crate::{util::*, Properties}; +use azure_core::prelude::*; +use azure_core::{ + headers::{add_mandatory_header2, add_optional_header2}, + AppendToUrlQuery, Response as HttpResponse, +}; +use azure_core::{ + headers::{etag_from_headers, last_modified_from_headers}, + Etag, +}; +use azure_storage::core::headers::CommonStorageResponseHeaders; +use chrono::{DateTime, Utc}; +use std::convert::{TryFrom, TryInto}; + +/// A future of a file system get properties response +type GetFileSystemProperties = + futures::future::BoxFuture<'static, crate::Result>; + +#[derive(Debug, Clone)] +pub struct GetFileSystemPropertiesBuilder { + client: FileSystemClient, + client_request_id: Option, + timeout: Option, +} + +impl GetFileSystemPropertiesBuilder { + pub(crate) fn new(client: FileSystemClient) -> Self { + Self { + client, + client_request_id: None, + timeout: None, + } + } + + setters! { + client_request_id: ClientRequestId => Some(client_request_id), + timeout: Timeout => Some(timeout), + } + + pub fn into_future(self) -> GetFileSystemProperties { + let this = self.clone(); + let ctx = self.client.context.clone(); + + Box::pin(async move { + let mut url = this.client.url().clone(); + self.timeout.append_to_url_query(&mut url); + url.query_pairs_mut().append_pair("resource", "filesystem"); + + let mut request = this + .client + .prepare_request_pipeline(url.as_str(), http::Method::HEAD); + + add_optional_header2(&this.client_request_id, &mut request)?; + add_mandatory_header2(&ContentLength::new(0), &mut request)?; + + let response = self + .client + .pipeline() + .send(&mut ctx.clone(), &mut request) + .await?; + + GetFileSystemPropertiesResponse::try_from(response).await + }) + } +} + +#[derive(Debug, Clone)] +pub struct GetFileSystemPropertiesResponse { + pub common_storage_response_headers: CommonStorageResponseHeaders, + pub etag: Etag, + pub last_modified: DateTime, + pub namespace_enabled: bool, + pub properties: Properties, +} + +impl GetFileSystemPropertiesResponse { + pub async fn try_from(response: HttpResponse) -> crate::Result { + let (_status_code, headers, _pinned_stream) = response.deconstruct(); + + Ok(GetFileSystemPropertiesResponse { + common_storage_response_headers: (&headers).try_into()?, + etag: Etag::from(etag_from_headers(&headers)?), + last_modified: last_modified_from_headers(&headers)?, + namespace_enabled: namespace_enabled_from_headers(&headers)?, + properties: Properties::try_from(&headers)?, + }) + } +} diff --git a/sdk/storage_datalake/src/operations/file_system_set_properties.rs b/sdk/storage_datalake/src/operations/file_system_set_properties.rs new file mode 100644 index 0000000000..f6be2571ca --- /dev/null +++ b/sdk/storage_datalake/src/operations/file_system_set_properties.rs @@ -0,0 +1,93 @@ +use crate::clients::FileSystemClient; +use crate::Properties; +use azure_core::prelude::*; +use azure_core::{ + headers::{add_mandatory_header2, add_optional_header2}, + AppendToUrlQuery, Response as HttpResponse, +}; +use azure_core::{ + headers::{etag_from_headers, last_modified_from_headers}, + Etag, +}; +use azure_storage::core::headers::CommonStorageResponseHeaders; +use chrono::{DateTime, Utc}; +use std::convert::TryInto; + +/// A future of a file system set properties response +type SetFileSystemProperties = + futures::future::BoxFuture<'static, crate::Result>; + +#[derive(Debug, Clone)] +pub struct SetFileSystemPropertiesBuilder { + client: FileSystemClient, + properties: Option, + if_modified_since_condition: Option, + client_request_id: Option, + timeout: Option, +} + +impl SetFileSystemPropertiesBuilder { + pub(crate) fn new(client: FileSystemClient, properties: Option) -> Self { + Self { + client, + if_modified_since_condition: None, + client_request_id: None, + timeout: None, + properties, + } + } + + setters! { + properties: Properties => Some(properties), + if_modified_since_condition: IfModifiedSinceCondition => Some(if_modified_since_condition), + client_request_id: ClientRequestId => Some(client_request_id), + timeout: Timeout => Some(timeout), + } + + pub fn into_future(self) -> SetFileSystemProperties { + let this = self.clone(); + let ctx = self.client.context.clone(); + + Box::pin(async move { + let mut url = this.client.url().clone(); + self.timeout.append_to_url_query(&mut url); + url.query_pairs_mut().append_pair("resource", "filesystem"); + + let mut request = this + .client + .prepare_request_pipeline(url.as_str(), http::Method::PATCH); + + add_optional_header2(&this.client_request_id, &mut request)?; + add_optional_header2(&this.if_modified_since_condition, &mut request)?; + add_optional_header2(&this.properties, &mut request)?; + add_mandatory_header2(&ContentLength::new(0), &mut request)?; + + let response = self + .client + .pipeline() + .send(&mut ctx.clone(), &mut request) + .await?; + + SetFileSystemPropertiesResponse::try_from(response).await + }) + } +} + +#[derive(Debug, Clone)] +pub struct SetFileSystemPropertiesResponse { + pub common_storage_response_headers: CommonStorageResponseHeaders, + pub etag: Etag, + pub last_modified: DateTime, +} + +impl SetFileSystemPropertiesResponse { + pub async fn try_from(response: HttpResponse) -> crate::Result { + let (_status_code, headers, _pinned_stream) = response.deconstruct(); + + Ok(SetFileSystemPropertiesResponse { + common_storage_response_headers: (&headers).try_into()?, + etag: Etag::from(etag_from_headers(&headers)?), + last_modified: last_modified_from_headers(&headers)?, + }) + } +} diff --git a/sdk/storage_datalake/src/operations/file_systems_list.rs b/sdk/storage_datalake/src/operations/file_systems_list.rs new file mode 100644 index 0000000000..4064c4297c --- /dev/null +++ b/sdk/storage_datalake/src/operations/file_systems_list.rs @@ -0,0 +1,119 @@ +use crate::clients::DataLakeClient; +use crate::file_system::{FileSystem, FileSystemList}; +use azure_core::AppendToUrlQuery; +use azure_core::{collect_pinned_stream, prelude::*, Pageable, Response}; +use azure_storage::core::headers::CommonStorageResponseHeaders; +use std::convert::TryInto; +use std::pin::Pin; + +#[derive(Debug, Clone)] +pub struct ListFileSystems { + client: DataLakeClient, + prefix: Option, + next_marker: Option, + max_results: Option, + client_request_id: Option, + timeout: Option, + context: Option, +} + +impl ListFileSystems { + pub(crate) fn new(client: DataLakeClient, context: Option) -> Self { + Self { + client, + prefix: None, + next_marker: None, + max_results: None, + client_request_id: None, + timeout: None, + context, + } + } + + setters! { + prefix: Prefix => Some(prefix), + next_marker: NextMarker => Some(next_marker), + max_results: MaxResults => Some(max_results), + client_request_id: ClientRequestId => Some(client_request_id), + timeout: Timeout => Some(timeout), + context: Context => Some(context), + } + + pub fn into_stream(self) -> Pin>> { + let make_request = move |continuation: Option| { + let this = self.clone(); + let ctx = self.context.clone().unwrap_or_default(); + + async move { + let mut url = url::Url::parse(this.client.url()).unwrap(); + url.query_pairs_mut().append_pair("resource", "account"); + this.prefix.append_to_url_query(&mut url); + this.max_results.append_to_url_query(&mut url); + this.timeout.append_to_url_query(&mut url); + + if let Some(c) = continuation { + let nm: NextMarker = c.into(); + nm.append_to_url_query_as_continuation(&mut url); + } else { + this.next_marker.append_to_url_query(&mut url); + }; + + let mut request = this + .client + .prepare_request_pipeline(url.as_str(), http::Method::GET); + + azure_core::headers::add_optional_header2(&this.client_request_id, &mut request)?; + + let response = this + .client + .pipeline() + .send(&mut ctx.clone(), &mut request) + .await?; + + match ListFileSystemsResponse::try_from(response).await { + Ok(r) => Ok(r), + Err(e) => Err(azure_core::Error::Other(Box::new(e))), + } + } + }; + + Box::pin(Pageable::new(make_request)) + } +} + +#[derive(Clone, Debug)] +pub struct ListFileSystemsResponse { + pub common_storage_response_headers: CommonStorageResponseHeaders, + pub file_systems: Vec, + pub next_marker: Option, +} + +impl ListFileSystemsResponse { + pub(crate) async fn try_from(response: Response) -> crate::Result { + let (_status_code, headers, pinned_stream) = response.deconstruct(); + let body = collect_pinned_stream(pinned_stream).await?; + let file_system_list: FileSystemList = serde_json::from_slice(&body)?; + + Ok(ListFileSystemsResponse { + common_storage_response_headers: (&headers).try_into()?, + file_systems: file_system_list.file_systems, + next_marker: NextMarker::from_header_optional(&headers)?, + }) + } +} + +impl Continuable for ListFileSystemsResponse { + fn continuation(&self) -> Option { + self.next_marker.clone().map(|m| m.as_str().into()) + } +} + +impl IntoIterator for ListFileSystemsResponse { + type Item = FileSystem; + + type IntoIter = std::vec::IntoIter; + + fn into_iter(self) -> Self::IntoIter { + self.file_systems.into_iter() + } +} diff --git a/sdk/storage_datalake/src/operations/mod.rs b/sdk/storage_datalake/src/operations/mod.rs index fdd0545d6c..ead3fbada0 100644 --- a/sdk/storage_datalake/src/operations/mod.rs +++ b/sdk/storage_datalake/src/operations/mod.rs @@ -7,9 +7,19 @@ mod file_create; mod file_delete; mod file_flush; mod file_rename; +mod file_system_create; +mod file_system_delete; +mod file_system_get_properties; +mod file_system_set_properties; +mod file_systems_list; pub use file_append::*; pub use file_create::*; pub use file_delete::*; pub use file_flush::*; pub use file_rename::*; +pub use file_system_create::*; +pub use file_system_delete::*; +pub use file_system_get_properties::*; +pub use file_system_set_properties::*; +pub use file_systems_list::*; diff --git a/sdk/storage_datalake/src/properties.rs b/sdk/storage_datalake/src/properties.rs index 66e96b818c..1792895e03 100644 --- a/sdk/storage_datalake/src/properties.rs +++ b/sdk/storage_datalake/src/properties.rs @@ -6,35 +6,35 @@ use std::collections::HashMap; use std::convert::TryFrom; #[derive(Debug, Clone, PartialEq, Eq)] -pub struct Properties<'a, 'b>(HashMap, Cow<'b, str>>); +pub struct Properties(HashMap, Cow<'static, str>>); const HEADER: &str = "x-ms-properties"; -impl<'a, 'b> Default for Properties<'a, 'b> { +impl Default for Properties { fn default() -> Self { Self::new() } } -impl<'a, 'b> Properties<'a, 'b> { +impl Properties { pub fn new() -> Self { Self(HashMap::new()) } - pub fn insert>, V: Into>>( + pub fn insert>, V: Into>>( &mut self, k: K, v: V, - ) -> Option> { + ) -> Option> { self.0.insert(k.into(), v.into()) } - pub fn hash_map(&self) -> &HashMap, Cow<'b, str>> { + pub fn hash_map(&self) -> &HashMap, Cow<'static, str>> { &self.0 } } -impl<'a, 'b> AddAsHeader for Properties<'a, 'b> { +impl AddAsHeader for Properties { fn add_as_header(&self, builder: Builder) -> Builder { // the header is a comma separated list of key=base64(value) see // [https://docs.microsoft.com/rest/api/storageservices/datalakestoragegen2/filesystem/create#request-headers](https://docs.microsoft.com/rest/api/storageservices/datalakestoragegen2/filesystem/create#request-headers) @@ -70,14 +70,14 @@ impl<'a, 'b> AddAsHeader for Properties<'a, 'b> { } } -impl TryFrom<&HeaderMap> for Properties<'static, 'static> { +impl TryFrom<&HeaderMap> for Properties { type Error = crate::Error; fn try_from(headers: &HeaderMap) -> Result { let mut properties = Self::new(); // this is probably too complicated. Should we split - // it in more maneageable code blocks? + // it in more manageable code blocks? // The logic is this: // 1. Look for the header. If not found return error // 2. Split the header value by comma diff --git a/sdk/storage_datalake/src/requests/create_file_system_builder.rs b/sdk/storage_datalake/src/requests/create_file_system_builder.rs deleted file mode 100644 index cdf172254d..0000000000 --- a/sdk/storage_datalake/src/requests/create_file_system_builder.rs +++ /dev/null @@ -1,68 +0,0 @@ -use crate::responses::*; -use crate::{clients::FileSystemClient, Properties}; -use azure_core::prelude::*; -use azure_core::{ - headers::add_optional_header, headers::add_optional_header_ref, AppendToUrlQuery, -}; -use http::method::Method; -use http::status::StatusCode; -use std::convert::TryInto; - -#[derive(Debug, Clone)] -pub struct CreateFileSystemBuilder<'a> { - file_system_client: &'a FileSystemClient, - client_request_id: Option, - timeout: Option, - properties: Option<&'a Properties<'a, 'a>>, -} - -impl<'a> CreateFileSystemBuilder<'a> { - pub(crate) fn new(file_system_client: &'a FileSystemClient) -> Self { - Self { - file_system_client, - client_request_id: None, - timeout: None, - properties: None, - } - } - - setters! { - client_request_id: ClientRequestId => Some(client_request_id), - timeout: Timeout => Some(timeout), - properties: &'a Properties<'a, 'a> => Some(properties), - } - - pub async fn execute( - &self, - ) -> Result> { - // we clone this so we can add custom - // query parameters - let mut url = self.file_system_client.url().clone(); - - url.query_pairs_mut().append_pair("resource", "filesystem"); - self.timeout.append_to_url_query(&mut url); - - debug!("url = {}", url); - - let request = self.file_system_client.prepare_request( - url.as_str(), - &Method::PUT, - &|mut request| { - request = add_optional_header(&self.client_request_id, request); - request = add_optional_header_ref(&self.properties, request); - request - }, - None, - )?; - - debug!("request == {:?}", request); - - let response = self - .file_system_client - .http_client() - .execute_request_check_status(request.0, StatusCode::CREATED) - .await?; - - Ok((&response).try_into()?) - } -} diff --git a/sdk/storage_datalake/src/requests/delete_file_system_builder.rs b/sdk/storage_datalake/src/requests/delete_file_system_builder.rs deleted file mode 100644 index e38cf84896..0000000000 --- a/sdk/storage_datalake/src/requests/delete_file_system_builder.rs +++ /dev/null @@ -1,66 +0,0 @@ -use crate::clients::FileSystemClient; -use crate::responses::*; -use azure_core::prelude::*; -use azure_core::{headers::add_optional_header, AppendToUrlQuery}; -use http::method::Method; -use http::status::StatusCode; -use std::convert::TryInto; - -#[derive(Debug, Clone)] -pub struct DeleteFileSystemBuilder<'a> { - file_system_client: &'a FileSystemClient, - if_modified_since_condition: Option, - client_request_id: Option, - timeout: Option, -} - -impl<'a> DeleteFileSystemBuilder<'a> { - pub(crate) fn new(file_system_client: &'a FileSystemClient) -> Self { - Self { - file_system_client, - if_modified_since_condition: None, - client_request_id: None, - timeout: None, - } - } - - setters! { - if_modified_since_condition: IfModifiedSinceCondition => Some(if_modified_since_condition), - client_request_id: ClientRequestId => Some(client_request_id), - timeout: Timeout => Some(timeout), - } - - pub async fn execute( - &self, - ) -> Result> { - // we clone this so we can add custom - // query parameters - let mut url = self.file_system_client.url().clone(); - - url.query_pairs_mut().append_pair("resource", "filesystem"); - self.timeout.append_to_url_query(&mut url); - - debug!("url = {}", url); - - let request = self.file_system_client.prepare_request( - url.as_str(), - &Method::DELETE, - &|mut request| { - request = add_optional_header(&self.if_modified_since_condition, request); - request = add_optional_header(&self.client_request_id, request); - request - }, - None, - )?; - - debug!("request == {:?}", request); - - let response = self - .file_system_client - .http_client() - .execute_request_check_status(request.0, StatusCode::ACCEPTED) - .await?; - - Ok((&response).try_into()?) - } -} diff --git a/sdk/storage_datalake/src/requests/get_file_system_properties_builder.rs b/sdk/storage_datalake/src/requests/get_file_system_properties_builder.rs deleted file mode 100644 index 500fc4c3a3..0000000000 --- a/sdk/storage_datalake/src/requests/get_file_system_properties_builder.rs +++ /dev/null @@ -1,62 +0,0 @@ -use crate::clients::FileSystemClient; -use crate::responses::*; -use azure_core::prelude::*; -use azure_core::{headers::add_optional_header, AppendToUrlQuery}; -use http::method::Method; -use http::status::StatusCode; -use std::convert::TryInto; - -#[derive(Debug, Clone)] -pub struct GetFileSystemPropertiesBuilder<'a> { - file_system_client: &'a FileSystemClient, - client_request_id: Option, - timeout: Option, -} - -impl<'a> GetFileSystemPropertiesBuilder<'a> { - pub(crate) fn new(file_system_client: &'a FileSystemClient) -> Self { - Self { - file_system_client, - client_request_id: None, - timeout: None, - } - } - - setters! { - client_request_id: ClientRequestId => Some(client_request_id), - timeout: Timeout => Some(timeout), - } - - pub async fn execute( - &self, - ) -> Result> { - // we clone this so we can add custom - // query parameters - let mut url = self.file_system_client.url().clone(); - - url.query_pairs_mut().append_pair("resource", "filesystem"); - self.timeout.append_to_url_query(&mut url); - - debug!("url = {}", url); - - let request = self.file_system_client.prepare_request( - url.as_str(), - &Method::HEAD, - &|mut request| { - request = add_optional_header(&self.client_request_id, request); - request - }, - None, - )?; - - debug!("request == {:?}", request); - - let response = self - .file_system_client - .http_client() - .execute_request_check_status(request.0, StatusCode::OK) - .await?; - - Ok((&response).try_into()?) - } -} diff --git a/sdk/storage_datalake/src/requests/list_file_systems_builder.rs b/sdk/storage_datalake/src/requests/list_file_systems_builder.rs deleted file mode 100644 index 6d924cb724..0000000000 --- a/sdk/storage_datalake/src/requests/list_file_systems_builder.rs +++ /dev/null @@ -1,110 +0,0 @@ -use crate::clients::DataLakeClient; -use crate::responses::*; -use azure_core::prelude::*; -use azure_core::{headers::add_optional_header, AppendToUrlQuery}; -use futures::stream::{unfold, Stream}; -use http::method::Method; -use http::status::StatusCode; -use std::convert::TryInto; - -#[derive(Debug, Clone)] -pub struct ListFileSystemsBuilder<'a> { - data_lake_client: &'a DataLakeClient, - prefix: Option, - next_marker: Option, - max_results: Option, - client_request_id: Option, - timeout: Option, -} - -impl<'a> ListFileSystemsBuilder<'a> { - pub(crate) fn new(data_lake_client: &'a DataLakeClient) -> Self { - Self { - data_lake_client, - prefix: None, - next_marker: None, - max_results: None, - client_request_id: None, - timeout: None, - } - } - - setters! { - prefix: Prefix => Some(prefix), - next_marker: NextMarker => Some(next_marker), - max_results: MaxResults => Some(max_results), - client_request_id: ClientRequestId => Some(client_request_id), - timeout: Timeout => Some(timeout), - } - - pub async fn execute( - &self, - ) -> Result> { - let mut url = url::Url::parse(self.data_lake_client.url())?; - - url.query_pairs_mut().append_pair("resource", "account"); - - self.prefix.append_to_url_query(&mut url); - self.max_results.append_to_url_query(&mut url); - if let Some(nm) = self.next_marker.as_ref() { - nm.append_to_url_query_as_continuation(&mut url) - } - self.timeout.append_to_url_query(&mut url); - - debug!("list filesystems url = {}", url); - - let request = self.data_lake_client.prepare_request( - url.as_str(), - &Method::GET, - &|mut request| { - request = add_optional_header(&self.client_request_id, request); - request - }, - None, - )?; - - trace!("request == {:?}", request); - - let response = self - .data_lake_client - .http_client() - .execute_request_check_status(request.0, StatusCode::OK) - .await?; - - Ok((&response).try_into()?) - } - - pub fn stream( - self, - ) -> impl Stream>> + 'a - { - #[derive(Debug, Clone, PartialEq)] - enum States { - Init, - NextMarker(NextMarker), - } - - unfold(Some(States::Init), move |next_marker: Option| { - let req = self.clone(); - async move { - debug!("next_marker == {:?}", &next_marker); - let response = match next_marker { - Some(States::Init) => req.execute().await, - Some(States::NextMarker(next_marker)) => { - req.next_marker(next_marker).execute().await - } - None => return None, - }; - - let response = match response { - Ok(response) => response, - Err(err) => return Some((Err(err), None)), - }; - - let next_marker = response.next_marker.clone().map(States::NextMarker); - - Some((Ok(response), next_marker)) - } - }) - } -} diff --git a/sdk/storage_datalake/src/requests/mod.rs b/sdk/storage_datalake/src/requests/mod.rs deleted file mode 100644 index 854c70e704..0000000000 --- a/sdk/storage_datalake/src/requests/mod.rs +++ /dev/null @@ -1,10 +0,0 @@ -mod list_file_systems_builder; -pub use list_file_systems_builder::ListFileSystemsBuilder; -mod create_file_system_builder; -pub use create_file_system_builder::CreateFileSystemBuilder; -mod delete_file_system_builder; -pub use delete_file_system_builder::DeleteFileSystemBuilder; -mod get_file_system_properties_builder; -pub use get_file_system_properties_builder::GetFileSystemPropertiesBuilder; -mod set_file_system_properties_builder; -pub use set_file_system_properties_builder::SetFileSystemPropertiesBuilder; diff --git a/sdk/storage_datalake/src/requests/set_file_system_properties_builder.rs b/sdk/storage_datalake/src/requests/set_file_system_properties_builder.rs deleted file mode 100644 index 4f3907cc0c..0000000000 --- a/sdk/storage_datalake/src/requests/set_file_system_properties_builder.rs +++ /dev/null @@ -1,74 +0,0 @@ -use crate::responses::*; -use crate::{clients::FileSystemClient, Properties}; -use azure_core::prelude::*; -use azure_core::{ - headers::add_optional_header, headers::add_optional_header_ref, AppendToUrlQuery, -}; -use http::method::Method; -use http::status::StatusCode; -use std::convert::TryInto; - -#[derive(Debug, Clone)] -pub struct SetFileSystemPropertiesBuilder<'a> { - file_system_client: &'a FileSystemClient, - if_modified_since_condition: Option, - client_request_id: Option, - timeout: Option, - properties: Option<&'a Properties<'a, 'a>>, -} - -impl<'a> SetFileSystemPropertiesBuilder<'a> { - pub(crate) fn new( - file_system_client: &'a FileSystemClient, - properties: Option<&'a Properties<'a, 'a>>, - ) -> Self { - Self { - file_system_client, - if_modified_since_condition: None, - client_request_id: None, - timeout: None, - properties, - } - } - - setters! { - if_modified_since_condition: IfModifiedSinceCondition => Some(if_modified_since_condition), - client_request_id: ClientRequestId => Some(client_request_id), - timeout: Timeout => Some(timeout), - } - - pub async fn execute( - &self, - ) -> Result> { - // we clone this so we can add custom - // query parameters - let mut url = self.file_system_client.url().clone(); - - url.query_pairs_mut().append_pair("resource", "filesystem"); - self.timeout.append_to_url_query(&mut url); - - debug!("url = {}", url); - - let request = self.file_system_client.prepare_request( - url.as_str(), - &Method::PATCH, - &|mut request| { - request = add_optional_header(&self.if_modified_since_condition, request); - request = add_optional_header_ref(&self.properties, request); - request = add_optional_header(&self.client_request_id, request); - request - }, - None, - )?; - - debug!("request == {:?}", request); - - let response = self - .file_system_client - .http_client() - .execute_request_check_status(request.0, StatusCode::OK) - .await?; - - Ok((&response).try_into()?) - } -} diff --git a/sdk/storage_datalake/src/responses/create_file_system_response.rs b/sdk/storage_datalake/src/responses/create_file_system_response.rs deleted file mode 100644 index d993ca3239..0000000000 --- a/sdk/storage_datalake/src/responses/create_file_system_response.rs +++ /dev/null @@ -1,34 +0,0 @@ -use crate::util::*; -use azure_core::{ - headers::{etag_from_headers, last_modified_from_headers}, - Etag, -}; -use azure_storage::core::headers::CommonStorageResponseHeaders; -use bytes::Bytes; -use chrono::{DateTime, Utc}; -use http::Response; -use std::convert::{TryFrom, TryInto}; - -#[derive(Debug, Clone)] -pub struct CreateFileSystemResponse { - pub common_storage_response_headers: CommonStorageResponseHeaders, - pub etag: Etag, - pub last_modified: DateTime, - pub namespace_enabled: bool, -} - -impl TryFrom<&Response> for CreateFileSystemResponse { - type Error = crate::Error; - - fn try_from(response: &Response) -> Result { - trace!("body == {}", std::str::from_utf8(response.body())?); - trace!("headers == {:?}", response.headers()); - - Ok(CreateFileSystemResponse { - common_storage_response_headers: response.headers().try_into()?, - etag: Etag::from(etag_from_headers(response.headers())?), - last_modified: last_modified_from_headers(response.headers())?, - namespace_enabled: namespace_enabled_from_headers(response.headers())?, - }) - } -} diff --git a/sdk/storage_datalake/src/responses/delete_file_system_response.rs b/sdk/storage_datalake/src/responses/delete_file_system_response.rs deleted file mode 100644 index 04d2f2a778..0000000000 --- a/sdk/storage_datalake/src/responses/delete_file_system_response.rs +++ /dev/null @@ -1,22 +0,0 @@ -use azure_storage::core::headers::CommonStorageResponseHeaders; -use bytes::Bytes; -use http::Response; -use std::convert::{TryFrom, TryInto}; - -#[derive(Debug, Clone)] -pub struct DeleteFileSystemResponse { - pub common_storage_response_headers: CommonStorageResponseHeaders, -} - -impl TryFrom<&Response> for DeleteFileSystemResponse { - type Error = crate::Error; - - fn try_from(response: &Response) -> Result { - debug!("body == {}", std::str::from_utf8(response.body())?); - debug!("headers == {:?}", response.headers()); - - Ok(DeleteFileSystemResponse { - common_storage_response_headers: response.headers().try_into()?, - }) - } -} diff --git a/sdk/storage_datalake/src/responses/get_file_system_properties_response.rs b/sdk/storage_datalake/src/responses/get_file_system_properties_response.rs deleted file mode 100644 index 54529d1b96..0000000000 --- a/sdk/storage_datalake/src/responses/get_file_system_properties_response.rs +++ /dev/null @@ -1,36 +0,0 @@ -use crate::{util::*, Properties}; -use azure_core::{ - headers::{etag_from_headers, last_modified_from_headers}, - Etag, -}; -use azure_storage::core::headers::CommonStorageResponseHeaders; -use bytes::Bytes; -use chrono::{DateTime, Utc}; -use http::Response; -use std::convert::{TryFrom, TryInto}; - -#[derive(Debug, Clone)] -pub struct GetFileSystemPropertiesResponse { - pub common_storage_response_headers: CommonStorageResponseHeaders, - pub etag: Etag, - pub last_modified: DateTime, - pub namespace_enabled: bool, - pub properties: Properties<'static, 'static>, -} - -impl TryFrom<&Response> for GetFileSystemPropertiesResponse { - type Error = crate::Error; - - fn try_from(response: &Response) -> Result { - debug!("body == {}", std::str::from_utf8(response.body())?); - debug!("headers == {:?}", response.headers()); - - Ok(GetFileSystemPropertiesResponse { - common_storage_response_headers: response.headers().try_into()?, - etag: Etag::from(etag_from_headers(response.headers())?), - last_modified: last_modified_from_headers(response.headers())?, - namespace_enabled: namespace_enabled_from_headers(response.headers())?, - properties: response.headers().try_into()?, - }) - } -} diff --git a/sdk/storage_datalake/src/responses/list_file_systems_response.rs b/sdk/storage_datalake/src/responses/list_file_systems_response.rs deleted file mode 100644 index 47102b54a4..0000000000 --- a/sdk/storage_datalake/src/responses/list_file_systems_response.rs +++ /dev/null @@ -1,31 +0,0 @@ -use crate::file_system::FileSystemList; -use crate::FileSystem; -use azure_core::prelude::NextMarker; -use azure_storage::core::headers::CommonStorageResponseHeaders; -use bytes::Bytes; -use http::Response; -use std::convert::{TryFrom, TryInto}; - -#[derive(Debug, Clone)] -pub struct ListFileSystemsResponse { - pub common_storage_response_headers: CommonStorageResponseHeaders, - pub file_systems: Vec, - pub next_marker: Option, -} - -impl TryFrom<&Response> for ListFileSystemsResponse { - type Error = crate::Error; - - fn try_from(response: &Response) -> Result { - trace!("{}", std::str::from_utf8(response.body())?); - trace!("{:?}", response.headers()); - - let file_system_list: FileSystemList = response.try_into()?; - - Ok(ListFileSystemsResponse { - common_storage_response_headers: response.headers().try_into()?, - file_systems: file_system_list.file_systems, - next_marker: NextMarker::from_header_optional(response.headers())?, - }) - } -} diff --git a/sdk/storage_datalake/src/responses/mod.rs b/sdk/storage_datalake/src/responses/mod.rs deleted file mode 100644 index d6743e0fda..0000000000 --- a/sdk/storage_datalake/src/responses/mod.rs +++ /dev/null @@ -1,10 +0,0 @@ -mod list_file_systems_response; -pub use list_file_systems_response::ListFileSystemsResponse; -mod create_file_system_response; -pub use create_file_system_response::CreateFileSystemResponse; -mod delete_file_system_response; -pub use delete_file_system_response::DeleteFileSystemResponse; -mod get_file_system_properties_response; -pub use get_file_system_properties_response::GetFileSystemPropertiesResponse; -mod set_file_system_properties_response; -pub use set_file_system_properties_response::SetFileSystemPropertiesResponse; diff --git a/sdk/storage_datalake/src/responses/set_file_system_properties_response.rs b/sdk/storage_datalake/src/responses/set_file_system_properties_response.rs deleted file mode 100644 index a08b8e7af0..0000000000 --- a/sdk/storage_datalake/src/responses/set_file_system_properties_response.rs +++ /dev/null @@ -1,31 +0,0 @@ -use azure_core::{ - headers::{etag_from_headers, last_modified_from_headers}, - Etag, -}; -use azure_storage::core::headers::CommonStorageResponseHeaders; -use bytes::Bytes; -use chrono::{DateTime, Utc}; -use http::Response; -use std::convert::{TryFrom, TryInto}; - -#[derive(Debug, Clone)] -pub struct SetFileSystemPropertiesResponse { - pub common_storage_response_headers: CommonStorageResponseHeaders, - pub etag: Etag, - pub last_modified: DateTime, -} - -impl TryFrom<&Response> for SetFileSystemPropertiesResponse { - type Error = crate::Error; - - fn try_from(response: &Response) -> Result { - trace!("body == {}", std::str::from_utf8(response.body())?); - trace!("headers == {:?}", response.headers()); - - Ok(SetFileSystemPropertiesResponse { - common_storage_response_headers: response.headers().try_into()?, - etag: Etag::from(etag_from_headers(response.headers())?), - last_modified: last_modified_from_headers(response.headers())?, - }) - } -} diff --git a/sdk/storage_datalake/src/shared_key_authorization_policy.rs b/sdk/storage_datalake/src/shared_key_authorization_policy.rs index b6e0617b70..4ff951f549 100644 --- a/sdk/storage_datalake/src/shared_key_authorization_policy.rs +++ b/sdk/storage_datalake/src/shared_key_authorization_policy.rs @@ -1,5 +1,5 @@ use azure_core::{Context, Policy, PolicyResult, Request, Response}; -use azure_storage::storage_shared_key_credential::StorageSharedKeyCredential; +use azure_storage::core::storage_shared_key_credential::StorageSharedKeyCredential; use http::{HeaderMap, HeaderValue, Method}; use ring::hmac; use std::sync::Arc; @@ -45,14 +45,7 @@ impl Policy for SharedKeyAuthorizationPolicy { HeaderValue::from_str("2019-12-12")?, ); // TODO: Remove duplication with storage_account_client.rs - let uri_path = &request.uri().path_and_query().unwrap().to_string()[1..]; - let full_url = format!("{}/{}", self.base_url, uri_path); - // println!( - // "full_url used by SharedKeyAuthorizationPolicy == {:#?}", - // full_url - // ); - let url = url::Url::parse(full_url.as_str())?; - + let url = url::Url::parse(&request.uri().to_string()).unwrap(); let auth = generate_authorization( request.headers(), &url, diff --git a/sdk/storage_datalake/tests/data_lake.rs b/sdk/storage_datalake/tests/data_lake.rs index 8f9fc83a6e..1491146c1c 100644 --- a/sdk/storage_datalake/tests/data_lake.rs +++ b/sdk/storage_datalake/tests/data_lake.rs @@ -2,7 +2,6 @@ // #![cfg(feature = "mock_transport_framework")] use azure_core::prelude::*; -use azure_storage::core::prelude::*; use azure_storage::storage_shared_key_credential::StorageSharedKeyCredential; use azure_storage_datalake::prelude::*; use chrono::Utc; @@ -27,20 +26,18 @@ async fn test_data_lake_file_system_functions() -> Result<(), Box Result<(), Box Result<(), Box Result<(), Box Result<(), Box Result<(), Box Result<(), Box Result<(), Box Result<(), Box Result<(), Box Result