Remove UI related settings from CLI (#8783)

* Remove all ui reference in dapps interface

* Pass primary cli build

* Add back parity wallet dapp as builtin

* Clean up ui settings

* Fix all tests in cli

* Missed ui files to commit

* Add parity-utils endpoint back

* Fix non-dapp feature compiling

* Inline styles

* Remove parity-utils endpoint

* Remove ui precompiled crate

* Remove parity-ui alltogether

* Remove ui feature flags

* Move errors to static methods

* Fix tests

* Remove all reference to utils endpoint and remove server side injection

According to https://github.com/paritytech/parity/pull/8539, inject.js is already handled by Parity UI.

dapps/src/apps/fetcher/installers.rs

@@ -27,7 +27,6 @@ use mime_guess::Mime;
 use apps::manifest::{MANIFEST_FILENAME, deserialize_manifest, serialize_manifest, Manifest};
 use handlers::{ContentValidator, ValidatorResponse};
 use page::{local, PageCache};
-use Embeddable;
 
 type OnDone = Box<Fn(Option<local::Dapp>) + Send>;
 
@@ -124,17 +123,15 @@ pub struct Dapp {
 	id: String,
 	dapps_path: PathBuf,
 	on_done: OnDone,
-	embeddable_on: Embeddable,
 	pool: CpuPool,
 }
 
 impl Dapp {
-	pub fn new(id: String, dapps_path: PathBuf, on_done: OnDone, embeddable_on: Embeddable, pool: CpuPool) -> Self {
+	pub fn new(id: String, dapps_path: PathBuf, on_done: OnDone, pool: CpuPool) -> Self {
 		Dapp {
 			id,
 			dapps_path,
 			on_done,
-			embeddable_on,
 			pool,
 		}
 	}
@@ -170,7 +167,6 @@ impl ContentValidator for Dapp {
 	fn validate_and_install(self, response: fetch::Response) -> Result<ValidatorResponse, ValidationError> {
 		let id = self.id.clone();
 		let pool = self.pool;
-		let embeddable_on = self.embeddable_on;
 		let validate = move |dapp_path: PathBuf| {
 			let (file, zip_path) = write_response_and_check_hash(&id, dapp_path.clone(), &format!("{}.zip", id), response)?;
 			trace!(target: "dapps", "Opening dapp bundle at {:?}", zip_path);
@@ -210,7 +206,7 @@ impl ContentValidator for Dapp {
 			let mut manifest_file = fs::File::create(manifest_path)?;
 			manifest_file.write_all(manifest_str.as_bytes())?;
 			// Create endpoint
-			let endpoint = local::Dapp::new(pool, dapp_path, manifest.into(), PageCache::Enabled, embeddable_on);
+			let endpoint = local::Dapp::new(pool, dapp_path, manifest.into(), PageCache::Enabled);
 			Ok(endpoint)
 		};
 

dapps/src/apps/fetcher/mod.rs

@@ -31,7 +31,7 @@ use hash_fetch::urlhint::{URLHintContract, URLHint, URLHintResult};
 use hyper::StatusCode;
 
 use ethereum_types::H256;
-use {Embeddable, SyncStatus, random_filename};
+use {SyncStatus, random_filename};
 use parking_lot::Mutex;
 use page::local;
 use handlers::{ContentHandler, ContentFetcherHandler};
@@ -50,7 +50,6 @@ pub struct ContentFetcher<F: Fetch = FetchClient, R: URLHint + 'static = URLHint
 	resolver: R,
 	cache: Arc<Mutex<ContentCache>>,
 	sync: Arc<SyncStatus>,
-	embeddable_on: Embeddable,
 	fetch: F,
 	pool: CpuPool,
 	only_content: bool,
@@ -78,7 +77,6 @@ impl<R: URLHint + 'static, F: Fetch> ContentFetcher<F, R> {
 			resolver,
 			sync,
 			cache: Arc::new(Mutex::new(ContentCache::default())),
-			embeddable_on: None,
 			fetch,
 			pool,
 			only_content: true,
@@ -90,38 +88,30 @@ impl<R: URLHint + 'static, F: Fetch> ContentFetcher<F, R> {
 		self
 	}
 
-	pub fn embeddable_on(mut self, embeddable_on: Embeddable) -> Self {
-		self.embeddable_on = embeddable_on;
-		self
-	}
-
-	fn not_found(embeddable: Embeddable) -> endpoint::Response {
+	fn not_found() -> endpoint::Response {
 		Box::new(future::ok(ContentHandler::error(
 			StatusCode::NotFound,
 			"Resource Not Found",
 			"Requested resource was not found.",
 			None,
-			embeddable,
 		).into()))
 	}
 
-	fn still_syncing(embeddable: Embeddable) -> endpoint::Response {
+	fn still_syncing() -> endpoint::Response {
 		Box::new(future::ok(ContentHandler::error(
 			StatusCode::ServiceUnavailable,
 			"Sync In Progress",
 			"Your node is still syncing. We cannot resolve any content before it's fully synced.",
 			Some("<a href=\"javascript:window.location.reload()\">Refresh</a>"),
-			embeddable,
 		).into()))
 	}
 
-	fn dapps_disabled(address: Embeddable) -> endpoint::Response {
+	fn dapps_disabled() -> endpoint::Response {
 		Box::new(future::ok(ContentHandler::error(
 			StatusCode::ServiceUnavailable,
 			"Network Dapps Not Available",
 			"This interface doesn't support network dapps for security reasons.",
 			None,
-			address,
 		).into()))
 	}
 
@@ -195,10 +185,10 @@ impl<R: URLHint + 'static, F: Fetch> Endpoint for ContentFetcher<F, R> {
 					match content {
 						// Don't serve dapps if we are still syncing (but serve content)
 						Some(URLHintResult::Dapp(_)) if self.sync.is_major_importing() => {
-							(None, Self::still_syncing(self.embeddable_on.clone()))
+							(None, Self::still_syncing())
 						},
 						Some(URLHintResult::Dapp(_)) if self.only_content => {
-							(None, Self::dapps_disabled(self.embeddable_on.clone()))
+							(None, Self::dapps_disabled())
 						},
 						Some(content) => {
 							let handler = match content {
@@ -211,10 +201,8 @@ impl<R: URLHint + 'static, F: Fetch> Endpoint for ContentFetcher<F, R> {
 											content_id.clone(),
 											self.cache_path.clone(),
 											Box::new(on_done),
-											self.embeddable_on.clone(),
 											self.pool.clone(),
 										),
-										self.embeddable_on.clone(),
 										self.fetch.clone(),
 										self.pool.clone(),
 									)
@@ -228,10 +216,8 @@ impl<R: URLHint + 'static, F: Fetch> Endpoint for ContentFetcher<F, R> {
 											content_id.clone(),
 											self.cache_path.clone(),
 											Box::new(on_done),
-											self.embeddable_on.clone(),
 											self.pool.clone(),
 										),
-										self.embeddable_on.clone(),
 										self.fetch.clone(),
 										self.pool.clone(),
 									)
@@ -248,7 +234,6 @@ impl<R: URLHint + 'static, F: Fetch> Endpoint for ContentFetcher<F, R> {
 											Box::new(on_done),
 											self.pool.clone(),
 										),
-										self.embeddable_on.clone(),
 										self.fetch.clone(),
 										self.pool.clone(),
 									)
@@ -258,12 +243,12 @@ impl<R: URLHint + 'static, F: Fetch> Endpoint for ContentFetcher<F, R> {
 							(Some(ContentStatus::Fetching(handler.fetch_control())), Box::new(handler) as endpoint::Response)
 						},
 						None if self.sync.is_major_importing() => {
-							(None, Self::still_syncing(self.embeddable_on.clone()))
+							(None, Self::still_syncing())
 						},
 						None => {
 							// This may happen when sync status changes in between
 							// `contains` and `to_handler`
-							(None, Self::not_found(self.embeddable_on.clone()))
+							(None, Self::not_found())
 						},
 					}
 				},
@@ -330,7 +315,7 @@ mod tests {
 			icon_url: "".into(),
 			local_url: Some("".into()),
 			allow_js_eval: None,
-		}, Default::default(), None);
+		}, Default::default());
 
 		// when
 		fetcher.set_status("test", ContentStatus::Ready(handler));

dapps/src/apps/fs.rs

@@ -24,7 +24,6 @@ use futures_cpupool::CpuPool;
 use apps::manifest::{MANIFEST_FILENAME, deserialize_manifest};
 use endpoint::{Endpoint, EndpointInfo};
 use page::{local, PageCache};
-use Embeddable;
 
 struct LocalDapp {
 	id: String,
@@ -65,14 +64,14 @@ fn read_manifest(name: &str, mut path: PathBuf) -> EndpointInfo {
 /// Returns Dapp Id and Local Dapp Endpoint for given filesystem path.
 /// Parses the path to extract last component (for name).
 /// `None` is returned when path is invalid or non-existent.
-pub fn local_endpoint<P: AsRef<Path>>(path: P, embeddable: Embeddable, pool: CpuPool) -> Option<(String, Box<local::Dapp>)> {
+pub fn local_endpoint<P: AsRef<Path>>(path: P, pool: CpuPool) -> Option<(String, Box<local::Dapp>)> {
 	let path = path.as_ref().to_owned();
 	path.canonicalize().ok().and_then(|path| {
 		let name = path.file_name().and_then(|name| name.to_str());
 		name.map(|name| {
 			let dapp = local_dapp(name.into(), path.clone());
 			(dapp.id, Box::new(local::Dapp::new(
-				pool.clone(), dapp.path, dapp.info, PageCache::Disabled, embeddable.clone())
+				pool.clone(), dapp.path, dapp.info, PageCache::Disabled)
 			))
 		})
 	})
@@ -90,12 +89,12 @@ fn local_dapp(name: String, path: PathBuf) -> LocalDapp {
 
 /// Returns endpoints for Local Dapps found for given filesystem path.
 /// Scans the directory and collects `local::Dapp`.
-pub fn local_endpoints<P: AsRef<Path>>(dapps_path: P, embeddable: Embeddable, pool: CpuPool) -> BTreeMap<String, Box<Endpoint>> {
+pub fn local_endpoints<P: AsRef<Path>>(dapps_path: P, pool: CpuPool) -> BTreeMap<String, Box<Endpoint>> {
 	let mut pages = BTreeMap::<String, Box<Endpoint>>::new();
 	for dapp in local_dapps(dapps_path.as_ref()) {
 		pages.insert(
 			dapp.id,
-			Box::new(local::Dapp::new(pool.clone(), dapp.path, dapp.info, PageCache::Disabled, embeddable.clone()))
+			Box::new(local::Dapp::new(pool.clone(), dapp.path, dapp.info, PageCache::Disabled))
 		);
 	}
 	pages

dapps/src/apps/mod.rs

@@ -17,17 +17,15 @@
 use std::path::PathBuf;
 use std::sync::Arc;
 
-use endpoint::{Endpoints, Endpoint};
+use endpoint::Endpoints;
 use futures_cpupool::CpuPool;
-use page;
 use proxypac::ProxyPac;
 use web::Web;
 use fetch::Fetch;
-use {WebProxyTokens, ParentFrameSettings};
+use WebProxyTokens;
 
 mod app;
 mod cache;
-mod ui;
 pub mod fs;
 pub mod fetcher;
 pub mod manifest;
@@ -35,70 +33,37 @@ pub mod manifest;
 pub use self::app::App;
 
 pub const HOME_PAGE: &'static str = "home";
-pub const RPC_PATH: &'static str =  "rpc";
-pub const API_PATH: &'static str =  "api";
-pub const UTILS_PATH: &'static str =  "parity-utils";
+pub const RPC_PATH: &'static str = "rpc";
+pub const API_PATH: &'static str = "api";
 pub const WEB_PATH: &'static str = "web";
 pub const URL_REFERER: &'static str = "__referer=";
 
-pub fn utils(pool: CpuPool) -> Box<Endpoint> {
-	Box::new(page::builtin::Dapp::new(pool, ::parity_ui::App::default()))
-}
-
-pub fn ui(pool: CpuPool) -> Box<Endpoint> {
-	Box::new(page::builtin::Dapp::with_fallback_to_index(pool, ::parity_ui::App::default()))
-}
-
-pub fn ui_deprecation(pool: CpuPool) -> Box<Endpoint> {
-	Box::new(page::builtin::Dapp::with_fallback_to_index(pool, ::parity_ui_deprecation::App::default()))
-}
-
-pub fn ui_redirection(embeddable: Option<ParentFrameSettings>) -> Box<Endpoint> {
-	Box::new(ui::Redirection::new(embeddable))
-}
-
 pub fn all_endpoints<F: Fetch>(
 	dapps_path: PathBuf,
 	extra_dapps: Vec<PathBuf>,
 	dapps_domain: &str,
-	embeddable: Option<ParentFrameSettings>,
 	web_proxy_tokens: Arc<WebProxyTokens>,
 	fetch: F,
 	pool: CpuPool,
 ) -> (Vec<String>, Endpoints) {
 	// fetch fs dapps at first to avoid overwriting builtins
-	let mut pages = fs::local_endpoints(dapps_path.clone(), embeddable.clone(), pool.clone());
+	let mut pages = fs::local_endpoints(dapps_path.clone(), pool.clone());
 	let local_endpoints: Vec<String> = pages.keys().cloned().collect();
 	for path in extra_dapps {
-		if let Some((id, endpoint)) = fs::local_endpoint(path.clone(), embeddable.clone(), pool.clone()) {
+		if let Some((id, endpoint)) = fs::local_endpoint(path.clone(), pool.clone()) {
 			pages.insert(id, endpoint);
 		} else {
 			warn!(target: "dapps", "Ignoring invalid dapp at {}", path.display());
 		}
 	}
 
-	// NOTE [ToDr] Dapps will be currently embeded on 8180
-	pages.insert(
-		"ui".into(),
-		Box::new(page::builtin::Dapp::new_safe_to_embed(pool.clone(), ::parity_ui::App::default(), embeddable.clone()))
-	);
-	// old version
-	pages.insert(
-		"v1".into(),
-		Box::new({
-			let mut page = page::builtin::Dapp::new_safe_to_embed(pool.clone(), ::parity_ui::old::App::default(), embeddable.clone());
-			// allow JS eval on old Wallet
-			page.allow_js_eval();
-			page
-		})
-	);
 	pages.insert(
 		"proxy".into(),
-		ProxyPac::boxed(embeddable.clone(), dapps_domain.to_owned())
+		ProxyPac::boxed(dapps_domain.to_owned())
 	);
 	pages.insert(
 		WEB_PATH.into(),
-		Web::boxed(embeddable.clone(), web_proxy_tokens.clone(), fetch.clone(), pool.clone())
+		Web::boxed(web_proxy_tokens.clone(), fetch.clone(), pool.clone())
 	);
 
 	(local_endpoints, pages)

dapps/src/apps/ui.rs

@@ -1,57 +0,0 @@
-// Copyright 2015-2018 Parity Technologies (UK) Ltd.
-// This file is part of Parity.
-
-// Parity is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// Parity is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
-
-//! UI redirections
-
-use hyper::StatusCode;
-use futures::future;
-
-use endpoint::{Endpoint, Request, Response, EndpointPath};
-use {handlers, Embeddable};
-
-/// Redirection to UI server.
-pub struct Redirection {
-	embeddable_on: Embeddable,
-}
-
-impl Redirection {
-	pub fn new(
-		embeddable_on: Embeddable,
-	) -> Self {
-		Redirection {
-			embeddable_on,
-		}
-	}
-}
-
-impl Endpoint for Redirection {
-	fn respond(&self, _path: EndpointPath, req: Request) -> Response {
-		Box::new(future::ok(if let Some(ref frame) = self.embeddable_on {
-			trace!(target: "dapps", "Redirecting to signer interface.");
-			let protocol = req.uri().scheme().unwrap_or("http");
-			handlers::Redirection::new(format!("{}://{}:{}", protocol, &frame.host, frame.port)).into()
-		} else {
-			trace!(target: "dapps", "Signer disabled, returning 404.");
-			handlers::ContentHandler::error(
-				StatusCode::NotFound,
-				"404 Not Found",
-				"Your homepage is not available when Trusted Signer is disabled.",
-				Some("You can still access dapps by writing a correct address, though. Re-enable Signer to get your homepage back."),
-				None,
-			).into()
-		}))
-	}
-}