Merge pull request #5 from MindFlavor/candidate

put and clear page, max_results and next_marker in Blob::list, refactoring

Author: MindFlavor

.travis.yml

@@ -43,4 +43,4 @@ env:
     # override the default `--features unstable` used for the nightly branch (optional)
     - TRAVIS_CARGO_NIGHTLY_FEATURE=""
     # encrypted github token for doc upload (see `GH_TOKEN` link above)
-    - secure: "..."
+    - secure: "${GH_TOKEN}"

CHANGELOG.md

@@ -1,5 +1,18 @@
 # Change Log
 
+## [0.0.6](https://github.com/MindFlavor/AzureSDKForRust/releases/tag/0.0.6) (2016-01-12)
+
+**Implemented features:**
+* Added support for max_results in list_blobs. Now you can limit how many blobs could be returned by a single call.
+* Added support for next_marker in list_blobs. Now you can continue enumerating your blobs in subsequent calls.
+* Added put page for page blobs.
+* Added clear page for page blobs.
+
+**Refactoring:**
+* Added page constraints (512-bytes aligned).
+* Most methods moved from storage::Client to correct structs (ie storage::container::Container and storage::blob::Blob).
+* Moved list_blobs options in a separate structure (```azure::storage::blob::ListBlobOptions```).
+
 ## [0.0.5](https://github.com/MindFlavor/AzureSDKForRust/releases/tag/0.0.5) (2016-01-05)
 
 **Implemented features:**

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "azure_sdk_for_rust"
-version = "0.0.5"
+version = "0.0.6"
 authors = ["Francesco Cogno <[email protected]>"]
 
 [dependencies]

Cargo.toml

@@ -16,31 +16,89 @@ Although I am a Microsoft employee, this is not a Microsoft endorsed project. It
 You can find examples in the test section (not yet existent as far as Azure is concerned) and in the main.rs file. Here is a sample however:
 
 ```rust
-use azure::storage::client;
-use azure::storage::container::PublicAccess;
+extern crate azure_sdk_for_rust;
+extern crate chrono;
+#[macro_use]
+extern crate mime;
+
+use azure::storage::{LeaseState, LeaseStatus};
+use azure::storage::client::Client;
+use azure::storage::blob::{Blob, BlobType};
+use azure::storage::container::{Container, PublicAccess};
+
+use chrono::UTC;
+
+use mime::Mime;
 
 fn main() {
-	let azure_storage_account = &"azure_storage_account";
-	let azure_storage_key= &"azure_storage_key";
-
-	// create the client struct. The third argument, if false, forces to use
-	// http instead of https. It's useful if you have trouble compiling
-	// hyper with openSSL activated.
-    let client = client::new(azure_storage_account, azure_storage_key, false);
-
-	// This call will create a new Azure Container called "wow"
-	// with public blob access (see https://msdn.microsoft.com/en-us/library/azure/dd179468.aspx).
-    client.create_container("wow", PublicAccess::Blob).unwrap();
-
-	// This call will list your containers.
-    let mut ret = client.list_containers().unwrap();
-    println!("{:?}", ret);
-
-	// This code will look for the "todelete" container and
-	// remove from Azure.
-    let mut to_delete = ret.iter_mut().find(|x| x.name == "todelete").unwrap();
-    to_delete.delete(&client).unwrap();
-    println!("{:?} deleted!", to_delete);
+  let azure_storage_account = &"azure_storage_account";
+  let azure_storage_key= &"azure_storage_key";
+
+  // create the client struct. The third argument, if false, forces to use
+  // http instead of https. It's useful if you have trouble compiling
+  // hyper with openSSL activated.
+  let client = client::new(azure_storage_account, azure_storage_key, false);
+
+
+  // This call will list your containers.
+  let containers = Container::list(&client).unwrap();
+  println!("{:?}", ret);
+
+  // This call will create a new Azure Container called "wow"
+  // with public blob access (see https://msdn.microsoft.com/en-us/library/azure/dd179468.aspx)
+  // if it doesn't exist already.
+  let cont = containers.iter().find(|x| x.name == container_name);
+  if let None = cont {
+  	Container::create(&client, container_name, PublicAccess::Blob).unwrap();
+  }
+
+  // this code will upload a file to the container just created.
+  {
+	use std::fs::metadata;
+	use std::fs::File;
+
+	let file_name: &'static str = "C:\\temp\\from_rust.txt";
+	let container_name: &'static str = "wow";
+
+	let metadata = metadata(file_name).unwrap();
+	let mut file = File::open(file_name).unwrap();
+
+	let new_blob = Blob {
+		name: "from_rust.txt".to_owned(),
+		snapshot_time: None,
+		last_modified: UTC::now(),
+		etag: "".to_owned(),
+		content_length: metadata.len(),
+		content_type: "application/octet-stream".parse::<Mime>().unwrap(),
+		content_encoding: None,
+		content_language: None,
+		content_md5: None,
+		cache_control: None,
+		x_ms_blob_sequence_number: None,
+		blob_type: BlobType::BlockBlob,
+		lease_status: LeaseStatus::Unlocked,
+		lease_state: LeaseState::Available,
+		lease_duration: None,
+		copy_id: None,
+		copy_status: None,
+		copy_source: None,
+		copy_progress: None,
+		copy_completion: None,
+		copy_status_description: None,
+	};
+
+	new_blob.put(&client,
+		 container_name,
+		 None,
+		 Some((&mut file, metadata.len())))
+		.unwrap();
+  }
+
+  // This code will look for the "todelete" container and
+  // remove from Azure.
+  let mut to_delete = ret.iter_mut().find(|x| x.name == "todelete").unwrap();
+  to_delete.delete(&client).unwrap();
+  println!("{:?} deleted!", to_delete);
 }
 ```
 

README.md

@@ -0,0 +1,140 @@
+use std::str::FromStr;
+use std::fmt;
+use std::num::ParseIntError;
+use azure::core::range::Range;
+use std::convert::Into;
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+pub struct BA512Range {
+    start: u64,
+    end: u64,
+}
+
+impl BA512Range {
+    pub fn start(&self) -> u64 {
+        self.start
+    }
+    pub fn end(&self) -> u64 {
+        self.end
+    }
+
+    pub fn new(start: u64, end: u64) -> Result<BA512Range, Not512ByteAlignedError> {
+        if start % 512 != 0 {
+            return Err(Not512ByteAlignedError::StartRange(start));
+        }
+        if (end + 1) % 512 != 0 {
+            return Err(Not512ByteAlignedError::EndRange(end));
+        }
+
+        Ok(BA512Range {
+            start: start,
+            end: end,
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Not512ByteAlignedError {
+    StartRange(u64),
+    EndRange(u64),
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ParseError {
+    SplitNotFound,
+    ParseIntError(ParseIntError),
+    Not512ByteAlignedError(Not512ByteAlignedError),
+}
+
+impl From<ParseIntError> for ParseError {
+    fn from(pie: ParseIntError) -> ParseError {
+        ParseError::ParseIntError(pie)
+    }
+}
+
+impl From<Not512ByteAlignedError> for ParseError {
+    fn from(nae: Not512ByteAlignedError) -> ParseError {
+        ParseError::Not512ByteAlignedError(nae)
+    }
+}
+
+impl Into<Range> for BA512Range {
+    fn into(self) -> Range {
+        Range {
+            start: self.start(),
+            end: self.end(),
+        }
+    }
+}
+
+impl FromStr for BA512Range {
+    type Err = ParseError;
+    fn from_str(s: &str) -> Result<BA512Range, ParseError> {
+        let v = s.split("/").collect::<Vec<&str>>();
+        if v.len() != 2 {
+            return Err(ParseError::SplitNotFound);
+        }
+
+        let cp_start = try!(v[0].parse::<u64>());
+        let cp_end = try!(v[1].parse::<u64>());
+
+
+
+        Ok(try!(BA512Range::new(cp_start, cp_end)))
+    }
+}
+
+impl fmt::Display for BA512Range {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}/{}", self.start, self.end)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_512range_parse() {
+        let range = "0/511".parse::<BA512Range>().unwrap();
+
+        assert_eq!(range.start, 0);
+        assert_eq!(range.end, 511);
+    }
+
+    #[test]
+    #[should_panic(expected = "ParseIntError(ParseIntError { kind: InvalidDigit })")]
+    fn test_512range_parse_panic_1() {
+        "abba/2000".parse::<BA512Range>().unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "SplitNotFound")]
+    fn test_512range_parse_panic_2() {
+        "1000-2000".parse::<BA512Range>().unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "Not512ByteAlignedError(StartRange(7))")]
+    fn test_512range_invalid_start_range() {
+        "7/511".parse::<BA512Range>().unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "Not512ByteAlignedError(EndRange(100))")]
+    fn test_512range_invalid_end_range() {
+        "0/100".parse::<BA512Range>().unwrap();
+    }
+
+    #[test]
+    fn test_512range_display() {
+        let range = BA512Range {
+            start: 0,
+            end: 511,
+        };
+
+        let txt = format!("{}", range);
+
+        assert_eq!(txt, "0/511");
+    }
+}