Merge pull request #106 from MindFlavor/emulator_support/pr

Added support for Azure storage emulator

Author: MindFlavor

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name           = "azure_sdk_for_rust"
-version        = "0.10.0"
+version        = "0.10.1"
 description    = "Rust wrappers around Microsoft Azure REST APIs"
 readme         = "README.md"
 authors        = ["Francesco Cogno <francesco.cogno@outlook.com>", "Max Gortman <mgortman@microsoft.com>", "Dong Liu <doliu@microsoft.com>"]

examples/emulator00.rs

@@ -0,0 +1,45 @@
+extern crate azure_sdk_for_rust;
+extern crate chrono;
+extern crate env_logger;
+extern crate futures;
+extern crate hyper;
+extern crate hyper_tls;
+extern crate log;
+extern crate md5;
+extern crate tokio_core;
+extern crate url;
+
+use azure_sdk_for_rust::prelude::*;
+use azure_sdk_for_rust::storage::container::PublicAccess;
+use futures::future::*;
+use std::error::Error;
+use tokio_core::reactor::Core;
+use url::Url;
+
+fn main() -> Result<(), Box<Error>> {
+    env_logger::init();
+
+    let mut core = Core::new()?;
+
+    // this is how you use the emulator.
+    let blob_storage_url = "http://127.0.0.1:10000";
+    let table_storage_url = "http://127.0.0.1:10002";
+    let client = Client::emulator(&Url::parse(blob_storage_url)?, &Url::parse(table_storage_url)?)?;
+
+    // create container
+    let future = client
+        .create_container()
+        .with_container_name("emulcont")
+        .with_public_access(PublicAccess::None)
+        .finalize();
+    core.run(future.map(|res| println!("{:?}", res)))?;
+
+    let future = client
+        .list_blobs()
+        .with_container_name("emulcont")
+        .with_include_metadata()
+        .finalize();
+    core.run(future.map(|res| println!("{:?}", res)))?;
+
+    Ok(())
+}

src/azure/core/parsing.rs

@@ -119,10 +119,12 @@ pub fn find_subnodes<'a>(node: &'a Element, subnode: &str) -> Vec<&'a Element> {
         .filter(|x| match **x {
             ElementNode(ref mynode) => mynode.name == subnode,
             _ => false,
-        }).map(|x| match *x {
+        })
+        .map(|x| match *x {
             ElementNode(ref mynode) => mynode,
             _ => unreachable!(),
-        }).collect::<Vec<_>>()
+        })
+        .collect::<Vec<_>>()
 }
 
 #[inline]

src/azure/storage/blob/mod.rs

@@ -224,7 +224,8 @@ impl Blob {
             .ok_or_else(|| {
                 static CL: header::HeaderName = header::CONTENT_LENGTH;
                 AzureError::HeaderNotFound(CL.as_str().to_owned())
-            })?.to_str()?
+            })?
+            .to_str()?
             .parse::<u64>()?;
         trace!("content_length == {:?}", content_length);
 
@@ -370,15 +371,15 @@ where
 {
     match params {
         Some(ref params) => format!(
-            "https://{}.blob.core.windows.net/{}/{}?{}",
-            t.client().account(),
+            "{}/{}/{}?{}",
+            t.client().blob_uri(),
             utf8_percent_encode(t.container_name(), COMPLETE_ENCODE_SET),
             utf8_percent_encode(t.blob_name(), COMPLETE_ENCODE_SET),
             params
         ),
         None => format!(
-            "https://{}.blob.core.windows.net/{}/{}",
-            t.client().account(),
+            "{}/{}/{}",
+            t.client().blob_uri(),
             utf8_percent_encode(t.container_name(), COMPLETE_ENCODE_SET),
             utf8_percent_encode(t.blob_name(), COMPLETE_ENCODE_SET)
         ),

src/azure/storage/client.rs

@@ -5,10 +5,7 @@ use azure::storage::{blob, container};
 use hyper::{self, Method};
 use hyper_tls;
 use std::borrow::Borrow;
-
-// Can be variant for different cloud environment
-const SERVICE_SUFFIX_BLOB: &str = ".blob.core.windows.net";
-const SERVICE_SUFFIX_TABLE: &str = ".table.core.windows.net";
+use url::Url;
 
 pub trait Blob {
     fn list_blobs<'a>(&'a self) -> blob::requests::ListBlobBuilder<'a, No>;
@@ -50,6 +47,8 @@ pub struct Client {
     account: String,
     key: String,
     hc: hyper::Client<hyper_tls::HttpsConnector<hyper::client::HttpConnector>>,
+    blob_uri: String,
+    table_uri: String,
 }
 
 impl Blob for Client {
@@ -174,14 +173,35 @@ impl Container for Client {
 
 impl Client {
     pub fn new(account: &str, key: &str) -> Result<Client, AzureError> {
-        use hyper;
+        Client::azure(account, key)
+    }
 
+    pub fn azure(account: &str, key: &str) -> Result<Client, AzureError> {
         let client = hyper::Client::builder().build(hyper_tls::HttpsConnector::new(4)?);
 
         Ok(Client {
             account: account.to_owned(),
             key: key.to_owned(),
             hc: client,
+            blob_uri: format!("https://{}.blob.core.windows.net", account),
+            table_uri: format!("https://{}.table.core.windows.net", account),
+        })
+    }
+
+    pub fn emulator(blob_storage_url: &Url, table_storage_url: &Url) -> Result<Client, AzureError> {
+        let client = hyper::Client::builder().build(hyper_tls::HttpsConnector::new(4)?);
+
+        let blob_uri = format!("{}devstoreaccount1", blob_storage_url.as_str());
+        debug!("blob_uri == {}", blob_uri);
+        let table_uri = format!("{}devstoreaccount1", table_storage_url.as_str());
+        debug!("table_uri == {}", table_uri);
+
+        Ok(Client {
+            account: "devstoreaccount1".to_owned(),
+            key: "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==".to_owned(),
+            hc: client,
+            blob_uri,
+            table_uri,
         })
     }
 
@@ -193,6 +213,16 @@ impl Client {
         &self.key
     }
 
+    #[inline]
+    pub(crate) fn blob_uri(&self) -> &str {
+        &self.blob_uri
+    }
+
+    #[inline]
+    pub(crate) fn table_uri(&self) -> &str {
+        &self.table_uri
+    }
+
     pub(crate) fn perform_request<F>(
         &self,
         uri: &str,
@@ -230,12 +260,9 @@ impl Client {
 
     /// Uri scheme + authority e.g. http://myaccount.table.core.windows.net/
     pub(crate) fn get_uri_prefix(&self, service_type: ServiceType) -> String {
-        "https://".to_owned()
-            + self.account()
-            + match service_type {
-                ServiceType::Blob => SERVICE_SUFFIX_BLOB,
-                ServiceType::Table => SERVICE_SUFFIX_TABLE,
-            }
-            + "/"
+        match service_type {
+            ServiceType::Blob => format!("{}/", self.blob_uri()),
+            ServiceType::Table => format!("{}/", self.table_uri()),
+        }
     }
 }

src/azure/storage/container/create_request.rs

@@ -229,14 +229,14 @@ where
 {
     match params {
         Some(ref params) => format!(
-            "https://{}.blob.core.windows.net/{}?{}",
-            t.client().account(),
+            "{}/{}?{}",
+            t.client().blob_uri(),
             utf8_percent_encode(t.container_name(), COMPLETE_ENCODE_SET),
             params
         ),
         None => format!(
-            "https://{}.blob.core.windows.net/{}",
-            t.client().account(),
+            "{}/{}",
+            t.client().blob_uri(),
             utf8_percent_encode(t.container_name(), COMPLETE_ENCODE_SET),
         ),
     }

src/azure/storage/container/mod.rs

@@ -250,13 +250,14 @@ impl<'a, ContainerNameSet, LeaseDurationSet> AcquireLeaseBuilder<'a, ContainerNa
 where
     ContainerNameSet: ToAssign,
     LeaseDurationSet: ToAssign,
-{}
+{
+}
 
 impl<'a> AcquireLeaseBuilder<'a, Yes, Yes> {
     pub fn finalize(self) -> impl Future<Item = AcquireLeaseResponse, Error = AzureError> {
         let mut uri = format!(
-            "https://{}.blob.core.windows.net/{}?comp=lease&restype=container",
-            self.client().account(),
+            "{}/{}?comp=lease&restype=container",
+            self.client().blob_uri(),
             self.container_name()
         );
 

src/azure/storage/container/requests/acquire_lease_builder.rs

@@ -192,8 +192,8 @@ impl<'a, ContainerNameSet> BreakLeaseBuilder<'a, ContainerNameSet> where Contain
 impl<'a> BreakLeaseBuilder<'a, Yes> {
     pub fn finalize(self) -> impl Future<Item = BreakLeaseResponse, Error = AzureError> {
         let mut uri = format!(
-            "https://{}.blob.core.windows.net/{}?comp=lease&restype=container",
-            self.client().account(),
+            "{}/{}?comp=lease&restype=container",
+            self.client().blob_uri(),
             self.container_name()
         );
 

src/azure/storage/container/requests/break_lease_builder.rs

@@ -165,7 +165,8 @@ impl<'a, ContainerNameSet, PublicAccessSet> CreateBuilder<'a, ContainerNameSet,
 where
     ContainerNameSet: ToAssign,
     PublicAccessSet: ToAssign,
-{}
+{
+}
 
 impl<'a, ContainerNameSet, PublicAccessSet> ContainerNameSupport<'a> for CreateBuilder<'a, ContainerNameSet, PublicAccessSet>
 where
@@ -214,11 +215,7 @@ impl<'a> CreateBuilder<'a, No, No> {
 
 impl<'a> CreateBuilder<'a, Yes, Yes> {
     pub fn finalize(self) -> impl Future<Item = (), Error = AzureError> {
-        let mut uri = format!(
-            "https://{}.blob.core.windows.net/{}?restype=container",
-            self.client().account(),
-            self.container_name()
-        );
+        let mut uri = format!("{}/{}?restype=container", self.client().blob_uri(), self.container_name());
 
         if let Some(nm) = TimeoutOption::to_uri_parameter(&self) {
             uri = format!("{}&{}", uri, nm);