Merge branch 'master' into lightsync

README.md

@@ -58,18 +58,18 @@ Parity is fully compatible with Stable Rust.
 
 We recommend installing Rust through [rustup](https://www.rustup.rs/). If you don't already have rustup, you can install it like this:
 
-- Linux and OSX:
+- Linux:
 	```bash
 	$ curl https://sh.rustup.rs -sSf | sh
 	```
 
-	Parity also requires `gcc`, `g++` and `make` packages to be installed.
+	Parity also requires `gcc`, `g++`, `libssl-dev`/`openssl` and `pkg-config` packages to be installed.
 - OSX:
 	```bash
 	$ curl https://sh.rustup.rs -sSf | sh
 	```
 
-	`clang` and `make` are required. These come with Xcode command line tools or can be installed with homebrew.
+	`clang` is required. It comes with Xcode command line tools or can be installed with homebrew.
 - Windows
 
     Make sure you have Visual Studio 2015 with C++ support installed. Next, download and run the rustup installer from

dapps/Cargo.toml

@@ -9,7 +9,7 @@ build = "build.rs"
 [lib]
 
 [dependencies]
-rand = "0.3.14"
+rand = "0.3"
 log = "0.3"
 env_logger = "0.3"
 futures = "0.1"

dapps/src/apps/cache.rs

@@ -17,14 +17,13 @@
 //! Fetchable Dapps support.
 
 use std::fs;
-use std::sync::{Arc};
 
 use linked_hash_map::LinkedHashMap;
 use page::LocalPageEndpoint;
 use handlers::FetchControl;
 
 pub enum ContentStatus {
-	Fetching(Arc<FetchControl>),
+	Fetching(FetchControl),
 	Ready(LocalPageEndpoint),
 }
 

dapps/src/apps/fetcher/installers.rs

@@ -23,7 +23,7 @@ use util::H256;
 
 use util::sha3::sha3;
 use page::{LocalPageEndpoint, PageCache};
-use handlers::ContentValidator;
+use handlers::{ContentValidator, ValidatorResponse};
 use apps::manifest::{MANIFEST_FILENAME, deserialize_manifest, serialize_manifest, Manifest};
 
 type OnDone = Box<Fn(Option<LocalPageEndpoint>) + Send>;
@@ -35,30 +35,30 @@ fn write_response_and_check_hash(
 	response: fetch::Response
 ) -> Result<(fs::File, PathBuf), ValidationError> {
 	// try to parse id
-	let id = try!(id.parse().map_err(|_| ValidationError::InvalidContentId));
+	let id = id.parse().map_err(|_| ValidationError::InvalidContentId)?;
 
 	// check if content exists
 	if content_path.exists() {
 		warn!(target: "dapps", "Overwriting existing content at 0x{:?}", id);
-		try!(fs::remove_dir_all(&content_path))
+		fs::remove_dir_all(&content_path)?
 	}
 
 	// create directory
-	try!(fs::create_dir_all(&content_path));
+	fs::create_dir_all(&content_path)?;
 
 	// append filename
 	content_path.push(filename);
 
 	// Now write the response
-	let mut file = io::BufWriter::new(try!(fs::File::create(&content_path)));
+	let mut file = io::BufWriter::new(fs::File::create(&content_path)?);
 	let mut reader = io::BufReader::new(response);
-	try!(io::copy(&mut reader, &mut file));
-	try!(file.flush());
+	io::copy(&mut reader, &mut file)?;
+	file.flush()?;
 
 	// Validate hash
 	// TODO [ToDr] calculate sha3 in-flight while reading the response
-	let mut file = io::BufReader::new(try!(fs::File::open(&content_path)));
-	let hash = try!(sha3(&mut file));
+	let mut file = io::BufReader::new(fs::File::open(&content_path)?);
+	let hash = sha3(&mut file)?;
 	if id == hash {
 		Ok((file.into_inner(), content_path))
 	} else {
@@ -90,10 +90,10 @@ impl Content {
 impl ContentValidator for Content {
 	type Error = ValidationError;
 
-	fn validate_and_install(&self, response: fetch::Response) -> Result<LocalPageEndpoint, ValidationError> {
+	fn validate_and_install(&self, response: fetch::Response) -> Result<ValidatorResponse, ValidationError> {
 		let validate = |content_path: PathBuf| {
 			// Create dir
-			let (_, content_path) = try!(write_response_and_check_hash(self.id.as_str(), content_path.clone(), self.id.as_str(), response));
+			let (_, content_path) = write_response_and_check_hash(self.id.as_str(), content_path.clone(), self.id.as_str(), response)?;
 
 			Ok(LocalPageEndpoint::single_file(content_path, self.mime.clone(), PageCache::Enabled))
 		};
@@ -108,7 +108,7 @@ impl ContentValidator for Content {
 			let _ = fs::remove_dir_all(&content_path);
 		}
 		(self.on_done)(result.as_ref().ok().cloned());
-		result
+		result.map(ValidatorResponse::Local)
 	}
 }
 
@@ -131,7 +131,7 @@ impl Dapp {
 
 	fn find_manifest(zip: &mut zip::ZipArchive<fs::File>) -> Result<(Manifest, PathBuf), ValidationError> {
 		for i in 0..zip.len() {
-			let mut file = try!(zip.by_index(i));
+			let mut file = zip.by_index(i)?;
 
 			if !file.name().ends_with(MANIFEST_FILENAME) {
 				continue;
@@ -157,20 +157,20 @@ impl Dapp {
 impl ContentValidator for Dapp {
 	type Error = ValidationError;
 
-	fn validate_and_install(&self, response: fetch::Response) -> Result<LocalPageEndpoint, ValidationError> {
+	fn validate_and_install(&self, response: fetch::Response) -> Result<ValidatorResponse, ValidationError> {
 		let validate = |dapp_path: PathBuf| {
-			let (file, zip_path) = try!(write_response_and_check_hash(self.id.as_str(), dapp_path.clone(), &format!("{}.zip", self.id), response));
+			let (file, zip_path) = write_response_and_check_hash(self.id.as_str(), dapp_path.clone(), &format!("{}.zip", self.id), response)?;
 			trace!(target: "dapps", "Opening dapp bundle at {:?}", zip_path);
 			// Unpack archive
-			let mut zip = try!(zip::ZipArchive::new(file));
+			let mut zip = zip::ZipArchive::new(file)?;
 			// First find manifest file
-			let (mut manifest, manifest_dir) = try!(Self::find_manifest(&mut zip));
+			let (mut manifest, manifest_dir) = Self::find_manifest(&mut zip)?;
 			// Overwrite id to match hash
 			manifest.id = self.id.clone();
 
 			// Unpack zip
 			for i in 0..zip.len() {
-				let mut file = try!(zip.by_index(i));
+				let mut file = zip.by_index(i)?;
 				let is_dir = file.name().chars().rev().next() == Some('/');
 
 				let file_path = PathBuf::from(file.name());
@@ -180,22 +180,22 @@ impl ContentValidator for Dapp {
 					let p = dapp_path.join(location_in_manifest_base);
 					// Check if it's a directory
 					if is_dir {
-						try!(fs::create_dir_all(p));
+						fs::create_dir_all(p)?;
 					} else {
-						let mut target = try!(fs::File::create(p));
-						try!(io::copy(&mut file, &mut target));
+						let mut target = fs::File::create(p)?;
+						io::copy(&mut file, &mut target)?;
 					}
 				}
 			}
 
 			// Remove zip
-			try!(fs::remove_file(&zip_path));
+			fs::remove_file(&zip_path)?;
 
 			// Write manifest
-			let manifest_str = try!(serialize_manifest(&manifest).map_err(ValidationError::ManifestSerialization));
+			let manifest_str = serialize_manifest(&manifest).map_err(ValidationError::ManifestSerialization)?;
 			let manifest_path = dapp_path.join(MANIFEST_FILENAME);
-			let mut manifest_file = try!(fs::File::create(manifest_path));
-			try!(manifest_file.write_all(manifest_str.as_bytes()));
+			let mut manifest_file = fs::File::create(manifest_path)?;
+			manifest_file.write_all(manifest_str.as_bytes())?;
 			// Create endpoint
 			let endpoint = LocalPageEndpoint::new(dapp_path, manifest.clone().into(), PageCache::Enabled, self.embeddable_on.clone());
 			Ok(endpoint)
@@ -211,7 +211,7 @@ impl ContentValidator for Dapp {
 			let _ = fs::remove_dir_all(&target);
 		}
 		(self.on_done)(result.as_ref().ok().cloned());
-		result
+		result.map(ValidatorResponse::Local)
 	}
 }
 

dapps/src/apps/fetcher/mod.rs

@@ -129,12 +129,12 @@ impl<R: URLHint + Send + Sync + 'static, F: Fetch> Fetcher for ContentFetcher<F,
 					(None, endpoint.to_async_handler(path, control))
 				},
 				// Content is already being fetched
-				Some(&mut ContentStatus::Fetching(ref fetch_control)) => {
+				Some(&mut ContentStatus::Fetching(ref fetch_control)) if !fetch_control.is_deadline_reached() => {
 					trace!(target: "dapps", "Content fetching in progress. Waiting...");
 					(None, fetch_control.to_async_handler(path, control))
 				},
 				// We need to start fetching the content
-				None => {
+				_ => {
 					trace!(target: "dapps", "Content unavailable. Fetching... {:?}", content_id);
 					let content_hex = content_id.from_hex().expect("to_handler is called only when `contains` returns true.");
 					let content = self.resolver.resolve(content_hex);
@@ -156,7 +156,7 @@ impl<R: URLHint + Send + Sync + 'static, F: Fetch> Fetcher for ContentFetcher<F,
 							(None, Self::still_syncing(self.embeddable_on.clone()))
 						},
 						Some(URLHintResult::Dapp(dapp)) => {
-							let (handler, fetch_control) = ContentFetcherHandler::new(
+							let handler = ContentFetcherHandler::new(
 								dapp.url(),
 								path,
 								control,
@@ -171,10 +171,10 @@ impl<R: URLHint + Send + Sync + 'static, F: Fetch> Fetcher for ContentFetcher<F,
 								self.fetch.clone(),
 							);
 
-							(Some(ContentStatus::Fetching(fetch_control)), Box::new(handler) as Box<Handler>)
+							(Some(ContentStatus::Fetching(handler.fetch_control())), Box::new(handler) as Box<Handler>)
 						},
 						Some(URLHintResult::Content(content)) => {
-							let (handler, fetch_control) = ContentFetcherHandler::new(
+							let handler = ContentFetcherHandler::new(
 								content.url,
 								path,
 								control,
@@ -189,7 +189,7 @@ impl<R: URLHint + Send + Sync + 'static, F: Fetch> Fetcher for ContentFetcher<F,
 								self.fetch.clone(),
 							);
 
-							(Some(ContentStatus::Fetching(fetch_control)), Box::new(handler) as Box<Handler>)
+							(Some(ContentStatus::Fetching(handler.fetch_control())), Box::new(handler) as Box<Handler>)
 						},
 						None if self.sync.is_major_importing() => {
 							(None, Self::still_syncing(self.embeddable_on.clone()))
@@ -224,7 +224,7 @@ mod tests {
 	use std::env;
 	use std::sync::Arc;
 	use util::Bytes;
-	use fetch::Client;
+	use fetch::{Fetch, Client};
 	use hash_fetch::urlhint::{URLHint, URLHintResult};
 	use parity_reactor::Remote;
 

dapps/src/apps/fs.rs

@@ -37,8 +37,8 @@ fn local_dapps(dapps_path: String) -> Vec<LocalDapp> {
 
 	let files = files.expect("Check is done earlier");
 	files.map(|dir| {
-			let entry = try!(dir);
-			let file_type = try!(entry.file_type());
+			let entry = dir?;
+			let file_type = entry.file_type()?;
 
 			// skip files
 			if file_type.is_file() {
@@ -79,7 +79,7 @@ fn read_manifest(name: &str, mut path: PathBuf) -> EndpointInfo {
 		.and_then(|mut f| {
 			// Reat file
 			let mut s = String::new();
-			try!(f.read_to_string(&mut s).map_err(|e| format!("{:?}", e)));
+			f.read_to_string(&mut s).map_err(|e| format!("{:?}", e))?;
 			// Try to deserialize manifest
 			deserialize_manifest(s)
 		})

dapps/src/apps/mod.rs

@@ -14,13 +14,15 @@
 // You should have received a copy of the GNU General Public License
 // along with Parity.  If not, see <http://www.gnu.org/licenses/>.
 
+use std::sync::Arc;
 use endpoint::{Endpoints, Endpoint};
 use page::PageEndpoint;
 use proxypac::ProxyPac;
 use web::Web;
 use fetch::Fetch;
 use parity_dapps::WebApp;
 use parity_reactor::Remote;
+use {WebProxyTokens};
 
 mod cache;
 mod fs;
@@ -40,14 +42,20 @@ pub fn utils() -> Box<Endpoint> {
 	Box::new(PageEndpoint::with_prefix(parity_ui::App::default(), UTILS_PATH.to_owned()))
 }
 
-pub fn all_endpoints<F: Fetch>(dapps_path: String, signer_address: Option<(String, u16)>, remote: Remote, fetch: F) -> Endpoints {
+pub fn all_endpoints<F: Fetch>(
+	dapps_path: String,
+	signer_address: Option<(String, u16)>,
+	web_proxy_tokens: Arc<WebProxyTokens>,
+	remote: Remote,
+	fetch: F,
+) -> Endpoints {
 	// fetch fs dapps at first to avoid overwriting builtins
 	let mut pages = fs::local_endpoints(dapps_path, signer_address.clone());
 
 	// NOTE [ToDr] Dapps will be currently embeded on 8180
 	insert::<parity_ui::App>(&mut pages, "ui", Embeddable::Yes(signer_address.clone()));
-	pages.insert("proxy".into(), ProxyPac::boxed(signer_address));
-	pages.insert(WEB_PATH.into(), Web::boxed(remote, fetch));
+	pages.insert("proxy".into(), ProxyPac::boxed(signer_address.clone()));
+	pages.insert(WEB_PATH.into(), Web::boxed(signer_address.clone(), web_proxy_tokens.clone(), remote.clone(), fetch.clone()));
 
 	pages
 }