diff --git a/dapps/src/apps/fetcher/installers.rs b/dapps/src/apps/fetcher/installers.rs index 5f0cc3722..28f81127a 100644 --- a/dapps/src/apps/fetcher/installers.rs +++ b/dapps/src/apps/fetcher/installers.rs @@ -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 { @@ -93,7 +93,7 @@ impl ContentValidator for Content { fn validate_and_install(&self, response: fetch::Response) -> Result { 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)) }; @@ -131,7 +131,7 @@ impl Dapp { fn find_manifest(zip: &mut zip::ZipArchive) -> 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; @@ -159,18 +159,18 @@ impl ContentValidator for Dapp { fn validate_and_install(&self, response: fetch::Response) -> Result { 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) diff --git a/dapps/src/apps/fs.rs b/dapps/src/apps/fs.rs index b7188b0b4..12bad2e3d 100644 --- a/dapps/src/apps/fs.rs +++ b/dapps/src/apps/fs.rs @@ -37,8 +37,8 @@ fn local_dapps(dapps_path: String) -> Vec { 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) }) diff --git a/dapps/src/lib.rs b/dapps/src/lib.rs index 50efbf466..9401dadc9 100644 --- a/dapps/src/lib.rs +++ b/dapps/src/lib.rs @@ -188,7 +188,7 @@ impl ServerBuilder { self.sync_status.clone(), self.web_proxy_tokens.clone(), self.remote.clone(), - try!(self.fetch()), + self.fetch()?, ) } @@ -206,7 +206,7 @@ impl ServerBuilder { self.sync_status.clone(), self.web_proxy_tokens.clone(), self.remote.clone(), - try!(self.fetch()), + self.fetch()?, ) } @@ -288,7 +288,7 @@ impl Server { }); let hosts = Self::allowed_hosts(hosts, format!("{}", addr)); - try!(hyper::Server::http(addr)) + hyper::Server::http(addr)? .handle(move |ctrl| router::Router::new( ctrl, signer_address.clone(), diff --git a/dapps/src/url.rs b/dapps/src/url.rs index b6fb88e67..be5867d8c 100644 --- a/dapps/src/url.rs +++ b/dapps/src/url.rs @@ -85,9 +85,9 @@ impl Url { _ => None, }; - let port = try!(raw_url.port_or_known_default().ok_or_else(|| format!("Unknown port for scheme: `{}`", raw_url.scheme()))); - let host = try!(raw_url.host().ok_or_else(|| "Valid host, because only data:, mailto: protocols does not have host.".to_owned())).to_owned(); - let path = try!(raw_url.path_segments().ok_or_else(|| "Valid path segments. In HTTP we won't get cannot-be-a-base URLs".to_owned())) + let port = raw_url.port_or_known_default().ok_or_else(|| format!("Unknown port for scheme: `{}`", raw_url.scheme()))?; + let host = raw_url.host().ok_or_else(|| "Valid host, because only data:, mailto: protocols does not have host.".to_owned())?.to_owned(); + let path = raw_url.path_segments().ok_or_else(|| "Valid path segments. In HTTP we won't get cannot-be-a-base URLs".to_owned())? .map(|part| part.to_owned()).collect(); let query = raw_url.query().map(|x| x.to_owned()); diff --git a/db/src/database.rs b/db/src/database.rs index 36f349e32..0381cf4cf 100644 --- a/db/src/database.rs +++ b/db/src/database.rs @@ -73,10 +73,10 @@ impl WriteCache { match *cache_entry { WriteCacheEntry::Write(ref val) => { - try!(batch.put(&key, val)); + batch.put(&key, val)?; }, WriteCacheEntry::Remove => { - try!(batch.delete(&key)); + batch.delete(&key)?; }, } key.clone() @@ -87,14 +87,14 @@ impl WriteCache { removed_so_far = removed_so_far + 1; } if removed_so_far > 0 { - try!(db.write(batch)); + db.write(batch)?; } Ok(()) } /// flushes until cache is empty fn flush_all(&mut self, db: &DB) -> Result<(), Error> { - while !self.is_empty() { try!(self.flush(db, FLUSH_BATCH_SIZE)); } + while !self.is_empty() { self.flush(db, FLUSH_BATCH_SIZE)?; } Ok(()) } @@ -104,7 +104,7 @@ impl WriteCache { fn try_shrink(&mut self, db: &DB) -> Result<(), Error> { if self.entries.len() > self.preferred_len { - try!(self.flush(db, FLUSH_BATCH_SIZE)); + self.flush(db, FLUSH_BATCH_SIZE)?; } Ok(()) } @@ -135,7 +135,7 @@ impl Database { if db_lock.is_none() { return Ok(()); } let db = db_lock.as_ref().unwrap(); - try!(cache_lock.try_shrink(&db)); + cache_lock.try_shrink(&db)?; Ok(()) } @@ -145,7 +145,7 @@ impl Database { if db_lock.is_none() { return Ok(()); } let db = db_lock.as_ref().expect("we should have exited with Ok(()) on the previous step"); - try!(cache_lock.flush_all(&db)); + cache_lock.flush_all(&db)?; Ok(()) } @@ -174,7 +174,7 @@ impl DatabaseService for Database { opts.set_block_based_table_factory(&block_opts); opts.set_prefix_extractor_fixed_size(size); } - *db = Some(try!(DB::open(&opts, &path))); + *db = Some(DB::open(&opts, &path)?); Ok(()) } @@ -185,7 +185,7 @@ impl DatabaseService for Database { } fn close(&self) -> Result<(), Error> { - try!(self.flush_all()); + self.flush_all()?; let mut db = self.db.write(); if db.is_none() { return Err(Error::IsClosed); } @@ -231,9 +231,9 @@ impl DatabaseService for Database { } } let db_lock = self.db.read(); - let db = try!(db_lock.as_ref().ok_or(Error::IsClosed)); + let db = db_lock.as_ref().ok_or(Error::IsClosed)?; - match try!(db.get(key)) { + match db.get(key)? { Some(db_vec) => { Ok(Some(db_vec.to_vec())) }, @@ -243,7 +243,7 @@ impl DatabaseService for Database { fn get_by_prefix(&self, prefix: &[u8]) -> Result>, Error> { let db_lock = self.db.read(); - let db = try!(db_lock.as_ref().ok_or(Error::IsClosed)); + let db = db_lock.as_ref().ok_or(Error::IsClosed)?; let mut iter = db.iterator(IteratorMode::From(prefix, Direction::Forward)); match iter.next() { @@ -255,14 +255,14 @@ impl DatabaseService for Database { fn is_empty(&self) -> Result { let db_lock = self.db.read(); - let db = try!(db_lock.as_ref().ok_or(Error::IsClosed)); + let db = db_lock.as_ref().ok_or(Error::IsClosed)?; Ok(db.iterator(IteratorMode::Start).next().is_none()) } fn iter(&self) -> Result { let db_lock = self.db.read(); - let db = try!(db_lock.as_ref().ok_or(Error::IsClosed)); + let db = db_lock.as_ref().ok_or(Error::IsClosed)?; let mut iterators = self.iterators.write(); let next_iterator = iterators.keys().last().unwrap_or(&0) + 1; diff --git a/db/src/lib.rs.in b/db/src/lib.rs.in index 31dbfd71c..26d6f66cc 100644 --- a/db/src/lib.rs.in +++ b/db/src/lib.rs.in @@ -52,27 +52,27 @@ impl std::convert::From for ServiceError { pub fn blocks_service_url(db_path: &str) -> Result { let mut path = PathBuf::from(db_path); - try!(::std::fs::create_dir_all(db_path)); + ::std::fs::create_dir_all(db_path)?; path.push("blocks.ipc"); Ok(format!("ipc://{}", path.to_str().unwrap())) } pub fn extras_service_url(db_path: &str) -> Result { let mut path = PathBuf::from(db_path); - try!(::std::fs::create_dir_all(db_path)); + ::std::fs::create_dir_all(db_path)?; path.push("extras.ipc"); Ok(format!("ipc://{}", path.to_str().unwrap())) } pub fn blocks_client(db_path: &str) -> Result { - let url = try!(blocks_service_url(db_path)); - let client = try!(nanoipc::generic_client::>(&url)); + let url = blocks_service_url(db_path)?; + let client = nanoipc::generic_client::>(&url)?; Ok(client) } pub fn extras_client(db_path: &str) -> Result { - let url = try!(extras_service_url(db_path)); - let client = try!(nanoipc::generic_client::>(&url)); + let url = extras_service_url(db_path)?; + let client = nanoipc::generic_client::>(&url)?; Ok(client) } diff --git a/ethash/src/compute.rs b/ethash/src/compute.rs index 269c3d863..efd0584d5 100644 --- a/ethash/src/compute.rs +++ b/ethash/src/compute.rs @@ -116,17 +116,17 @@ impl Light { pub fn from_file(block_number: u64) -> io::Result { let seed_compute = SeedHashCompute::new(); let path = Light::file_path(seed_compute.get_seedhash(block_number)); - let mut file = try!(File::open(path)); + let mut file = File::open(path)?; let cache_size = get_cache_size(block_number); - if try!(file.metadata()).len() != cache_size as u64 { + if file.metadata()?.len() != cache_size as u64 { return Err(io::Error::new(io::ErrorKind::Other, "Cache file size mismatch")); } let num_nodes = cache_size / NODE_BYTES; let mut nodes: Vec = Vec::new(); nodes.resize(num_nodes, unsafe { mem::uninitialized() }); let buf = unsafe { slice::from_raw_parts_mut(nodes.as_mut_ptr() as *mut u8, cache_size) }; - try!(file.read_exact(buf)); + file.read_exact(buf)?; Ok(Light { cache: nodes, block_number: block_number, @@ -144,16 +144,16 @@ impl Light { if deprecated.exists() { debug!(target: "ethash", "removing: {:?}", &deprecated); - try!(fs::remove_file(deprecated)); + fs::remove_file(deprecated)?; } } - try!(fs::create_dir_all(path.parent().unwrap())); - let mut file = try!(File::create(&path)); + fs::create_dir_all(path.parent().unwrap())?; + let mut file = File::create(&path)?; let cache_size = self.cache.len() * NODE_BYTES; let buf = unsafe { slice::from_raw_parts(self.cache.as_ptr() as *const u8, cache_size) }; - try!(file.write(buf)); + file.write(buf)?; Ok(path) } } diff --git a/ethcore/light/src/net/buffer_flow.rs b/ethcore/light/src/net/buffer_flow.rs index 61866f686..89ba2e6e8 100644 --- a/ethcore/light/src/net/buffer_flow.rs +++ b/ethcore/light/src/net/buffer_flow.rs @@ -135,10 +135,10 @@ impl RlpDecodable for CostTable { let mut header_proofs = None; for row in rlp.iter() { - let msg_id: u8 = try!(row.val_at(0)); + let msg_id: u8 = row.val_at(0)?; let cost = { - let base = try!(row.val_at(1)); - let per = try!(row.val_at(2)); + let base = row.val_at(1)?; + let per = row.val_at(2)?; Cost(base, per) }; @@ -155,12 +155,12 @@ impl RlpDecodable for CostTable { } Ok(CostTable { - headers: try!(headers.ok_or(DecoderError::Custom("No headers cost specified"))), - bodies: try!(bodies.ok_or(DecoderError::Custom("No bodies cost specified"))), - receipts: try!(receipts.ok_or(DecoderError::Custom("No receipts cost specified"))), - state_proofs: try!(state_proofs.ok_or(DecoderError::Custom("No proofs cost specified"))), - contract_codes: try!(contract_codes.ok_or(DecoderError::Custom("No contract codes specified"))), - header_proofs: try!(header_proofs.ok_or(DecoderError::Custom("No header proofs cost specified"))), + headers: headers.ok_or(DecoderError::Custom("No headers cost specified"))?, + bodies: bodies.ok_or(DecoderError::Custom("No bodies cost specified"))?, + receipts: receipts.ok_or(DecoderError::Custom("No receipts cost specified"))?, + state_proofs: state_proofs.ok_or(DecoderError::Custom("No proofs cost specified"))?, + contract_codes: contract_codes.ok_or(DecoderError::Custom("No contract codes specified"))?, + header_proofs: header_proofs.ok_or(DecoderError::Custom("No header proofs cost specified"))?, }) } } diff --git a/ethcore/light/src/net/mod.rs b/ethcore/light/src/net/mod.rs index 17898c24c..e76487b6d 100644 --- a/ethcore/light/src/net/mod.rs +++ b/ethcore/light/src/net/mod.rs @@ -143,7 +143,7 @@ impl Peer { flow_params.recharge(&mut self.local_buffer); let max_cost = flow_params.compute_cost(kind, max); - try!(self.local_buffer.deduct_cost(max_cost)); + self.local_buffer.deduct_cost(max_cost)?; Ok(max_cost) } @@ -275,14 +275,14 @@ impl LightProtocol { /// with an event. pub fn request_from(&self, io: &IoContext, peer_id: &PeerId, request: Request) -> Result { let peers = self.peers.read(); - let peer = try!(peers.get(peer_id).ok_or_else(|| Error::UnknownPeer)); + let peer = peers.get(peer_id).ok_or_else(|| Error::UnknownPeer)?; let mut peer = peer.lock(); match peer.remote_flow.as_mut() { Some(&mut (ref mut buf, ref flow)) => { flow.recharge(buf); let max = flow.compute_cost(request.kind(), request.amount()); - try!(buf.deduct_cost(max)); + buf.deduct_cost(max)?; } None => return Err(Error::NotServer), } @@ -386,8 +386,8 @@ impl LightProtocol { // - check whether request was made // - check whether request kinds match fn pre_verify_response(&self, peer: &PeerId, kind: request::Kind, raw: &UntrustedRlp) -> Result { - let req_id: usize = try!(raw.val_at(0)); - let cur_buffer: U256 = try!(raw.val_at(1)); + let req_id: usize = raw.val_at(0)?; + let cur_buffer: U256 = raw.val_at(1)?; trace!(target: "les", "pre-verifying response from peer {}, kind={:?}", peer, kind); @@ -582,7 +582,7 @@ impl LightProtocol { } }; - let (status, capabilities, flow_params) = try!(status::parse_handshake(data)); + let (status, capabilities, flow_params) = status::parse_handshake(data)?; trace!(target: "les", "Connected peer with chain head {:?}", (status.head_hash, status.head_num)); @@ -623,7 +623,7 @@ impl LightProtocol { return Ok(()) } - let announcement = try!(status::parse_announcement(data)); + let announcement = status::parse_announcement(data)?; // scope to ensure locks are dropped before moving into handler-space. { @@ -676,25 +676,25 @@ impl LightProtocol { let mut peer = peer.lock(); - let req_id: u64 = try!(data.val_at(0)); - let data = try!(data.at(1)); + let req_id: u64 = data.val_at(0)?; + let data = data.at(1)?; let start_block = { - if try!(data.at(0)).size() == 32 { - HashOrNumber::Hash(try!(data.val_at(0))) + if data.at(0)?.size() == 32 { + HashOrNumber::Hash(data.val_at(0)?) } else { - HashOrNumber::Number(try!(data.val_at(0))) + HashOrNumber::Number(data.val_at(0)?) } }; let req = request::Headers { start: start_block, - max: ::std::cmp::min(MAX_HEADERS, try!(data.val_at(1))), - skip: try!(data.val_at(2)), - reverse: try!(data.val_at(3)), + max: ::std::cmp::min(MAX_HEADERS, data.val_at(1)?), + skip: data.val_at(2)?, + reverse: data.val_at(3)?, }; - let max_cost = try!(peer.deduct_max(&self.flow_params, request::Kind::Headers, req.max)); + let max_cost = peer.deduct_max(&self.flow_params, request::Kind::Headers, req.max)?; let response = self.provider.block_headers(req); let actual_cost = self.flow_params.compute_cost(request::Kind::Headers, response.len()); @@ -717,8 +717,8 @@ impl LightProtocol { // Receive a response for block headers. fn block_headers(&self, peer: &PeerId, io: &IoContext, raw: UntrustedRlp) -> Result<(), Error> { - let req_id = try!(self.pre_verify_response(peer, request::Kind::Headers, &raw)); - let raw_headers: Vec<_> = try!(raw.at(2)).iter().map(|x| x.as_raw().to_owned()).collect(); + let req_id = self.pre_verify_response(peer, request::Kind::Headers, &raw)?; + let raw_headers: Vec<_> = raw.at(2)?.iter().map(|x| x.as_raw().to_owned()).collect(); for handler in &self.handlers { handler.on_block_headers(&Ctx { @@ -745,13 +745,16 @@ impl LightProtocol { }; let mut peer = peer.lock(); - let req_id: u64 = try!(data.val_at(0)); + let req_id: u64 = data.val_at(0)?; let req = request::Bodies { - block_hashes: try!(try!(data.at(1)).iter().take(MAX_BODIES).map(|x| x.as_val()).collect()) + block_hashes: data.at(1)?.iter() + .take(MAX_BODIES) + .map(|x| x.as_val()) + .collect::>()? }; - let max_cost = try!(peer.deduct_max(&self.flow_params, request::Kind::Bodies, req.block_hashes.len())); + let max_cost = peer.deduct_max(&self.flow_params, request::Kind::Bodies, req.block_hashes.len())?; let response = self.provider.block_bodies(req); let response_len = response.iter().filter(|x| &x[..] != &::rlp::EMPTY_LIST_RLP).count(); @@ -776,8 +779,8 @@ impl LightProtocol { // Receive a response for block bodies. fn block_bodies(&self, peer: &PeerId, io: &IoContext, raw: UntrustedRlp) -> Result<(), Error> { - let req_id = try!(self.pre_verify_response(peer, request::Kind::Bodies, &raw)); - let raw_bodies: Vec = try!(raw.at(2)).iter().map(|x| x.as_raw().to_owned()).collect(); + let req_id = self.pre_verify_response(peer, request::Kind::Bodies, &raw)?; + let raw_bodies: Vec = raw.at(2)?.iter().map(|x| x.as_raw().to_owned()).collect(); for handler in &self.handlers { handler.on_block_bodies(&Ctx { @@ -804,13 +807,16 @@ impl LightProtocol { }; let mut peer = peer.lock(); - let req_id: u64 = try!(data.val_at(0)); + let req_id: u64 = data.val_at(0)?; let req = request::Receipts { - block_hashes: try!(try!(data.at(1)).iter().take(MAX_RECEIPTS).map(|x| x.as_val()).collect()) + block_hashes: data.at(1)?.iter() + .take(MAX_RECEIPTS) + .map(|x| x.as_val()) + .collect::>()? }; - let max_cost = try!(peer.deduct_max(&self.flow_params, request::Kind::Receipts, req.block_hashes.len())); + let max_cost = peer.deduct_max(&self.flow_params, request::Kind::Receipts, req.block_hashes.len())?; let response = self.provider.receipts(req); let response_len = response.iter().filter(|x| &x[..] != &::rlp::EMPTY_LIST_RLP).count(); @@ -835,11 +841,11 @@ impl LightProtocol { // Receive a response for receipts. fn receipts(&self, peer: &PeerId, io: &IoContext, raw: UntrustedRlp) -> Result<(), Error> { - let req_id = try!(self.pre_verify_response(peer, request::Kind::Receipts, &raw)); - let raw_receipts: Vec> = try!(try!(raw.at(2)) + let req_id = self.pre_verify_response(peer, request::Kind::Receipts, &raw)?; + let raw_receipts: Vec> = raw.at(2)? .iter() .map(|x| x.as_val()) - .collect()); + .collect::>()?; for handler in &self.handlers { handler.on_receipts(&Ctx { @@ -866,24 +872,24 @@ impl LightProtocol { }; let mut peer = peer.lock(); - let req_id: u64 = try!(data.val_at(0)); + let req_id: u64 = data.val_at(0)?; let req = { - let requests: Result, Error> = try!(data.at(1)).iter().take(MAX_PROOFS).map(|x| { + let requests: Result, Error> = data.at(1)?.iter().take(MAX_PROOFS).map(|x| { Ok(request::StateProof { - block: try!(x.val_at(0)), - key1: try!(x.val_at(1)), - key2: if try!(x.at(2)).is_empty() { None } else { Some(try!(x.val_at(2))) }, - from_level: try!(x.val_at(3)), + block: x.val_at(0)?, + key1: x.val_at(1)?, + key2: if x.at(2)?.is_empty() { None } else { Some(x.val_at(2)?) }, + from_level: x.val_at(3)?, }) }).collect(); request::StateProofs { - requests: try!(requests), + requests: requests?, } }; - let max_cost = try!(peer.deduct_max(&self.flow_params, request::Kind::StateProofs, req.requests.len())); + let max_cost = peer.deduct_max(&self.flow_params, request::Kind::StateProofs, req.requests.len())?; let response = self.provider.proofs(req); let response_len = response.iter().filter(|x| &x[..] != &::rlp::EMPTY_LIST_RLP).count(); @@ -908,9 +914,9 @@ impl LightProtocol { // Receive a response for proofs. fn proofs(&self, peer: &PeerId, io: &IoContext, raw: UntrustedRlp) -> Result<(), Error> { - let req_id = try!(self.pre_verify_response(peer, request::Kind::StateProofs, &raw)); + let req_id = self.pre_verify_response(peer, request::Kind::StateProofs, &raw)?; - let raw_proofs: Vec> = try!(raw.at(2)).iter() + let raw_proofs: Vec> = raw.at(2)?.iter() .map(|x| x.iter().map(|node| node.as_raw().to_owned()).collect()) .collect(); @@ -939,22 +945,22 @@ impl LightProtocol { }; let mut peer = peer.lock(); - let req_id: u64 = try!(data.val_at(0)); + let req_id: u64 = data.val_at(0)?; let req = { - let requests: Result, Error> = try!(data.at(1)).iter().take(MAX_CODES).map(|x| { + let requests: Result, Error> = data.at(1)?.iter().take(MAX_CODES).map(|x| { Ok(request::ContractCode { - block_hash: try!(x.val_at(0)), - account_key: try!(x.val_at(1)), + block_hash: x.val_at(0)?, + account_key: x.val_at(1)?, }) }).collect(); request::ContractCodes { - code_requests: try!(requests), + code_requests: requests?, } }; - let max_cost = try!(peer.deduct_max(&self.flow_params, request::Kind::Codes, req.code_requests.len())); + let max_cost = peer.deduct_max(&self.flow_params, request::Kind::Codes, req.code_requests.len())?; let response = self.provider.contract_codes(req); let response_len = response.iter().filter(|x| !x.is_empty()).count(); @@ -979,9 +985,11 @@ impl LightProtocol { // Receive a response for contract code. fn contract_code(&self, peer: &PeerId, io: &IoContext, raw: UntrustedRlp) -> Result<(), Error> { - let req_id = try!(self.pre_verify_response(peer, request::Kind::Codes, &raw)); + let req_id = self.pre_verify_response(peer, request::Kind::Codes, &raw)?; - let raw_code: Vec = try!(try!(raw.at(2)).iter().map(|x| x.as_val()).collect()); + let raw_code: Vec = raw.at(2)?.iter() + .map(|x| x.as_val()) + .collect::>()?; for handler in &self.handlers { handler.on_code(&Ctx { @@ -1008,23 +1016,23 @@ impl LightProtocol { }; let mut peer = peer.lock(); - let req_id: u64 = try!(data.val_at(0)); + let req_id: u64 = data.val_at(0)?; let req = { - let requests: Result, Error> = try!(data.at(1)).iter().take(MAX_PROOFS).map(|x| { + let requests: Result, Error> = data.at(1)?.iter().take(MAX_PROOFS).map(|x| { Ok(request::HeaderProof { - cht_number: try!(x.val_at(0)), - block_number: try!(x.val_at(1)), - from_level: try!(x.val_at(2)), + cht_number: x.val_at(0)?, + block_number: x.val_at(1)?, + from_level: x.val_at(2)?, }) }).collect(); request::HeaderProofs { - requests: try!(requests), + requests: requests?, } }; - let max_cost = try!(peer.deduct_max(&self.flow_params, request::Kind::HeaderProofs, req.requests.len())); + let max_cost = peer.deduct_max(&self.flow_params, request::Kind::HeaderProofs, req.requests.len())?; let response = self.provider.header_proofs(req); let response_len = response.iter().filter(|x| &x[..] != ::rlp::EMPTY_LIST_RLP).count(); @@ -1051,13 +1059,15 @@ impl LightProtocol { fn header_proofs(&self, peer: &PeerId, io: &IoContext, raw: UntrustedRlp) -> Result<(), Error> { fn decode_res(raw: UntrustedRlp) -> Result<(Bytes, Vec), ::rlp::DecoderError> { Ok(( - try!(raw.val_at(0)), - try!(raw.at(1)).iter().map(|x| x.as_raw().to_owned()).collect(), + raw.val_at(0)?, + raw.at(1)?.iter().map(|x| x.as_raw().to_owned()).collect(), )) } - let req_id = try!(self.pre_verify_response(peer, request::Kind::HeaderProofs, &raw)); - let raw_proofs: Vec<_> = try!(try!(raw.at(2)).iter().map(decode_res).collect()); + let req_id = self.pre_verify_response(peer, request::Kind::HeaderProofs, &raw)?; + let raw_proofs: Vec<_> = raw.at(2)?.iter() + .map(decode_res) + .collect::>()?; for handler in &self.handlers { handler.on_header_proofs(&Ctx { @@ -1074,7 +1084,10 @@ impl LightProtocol { fn relay_transactions(&self, peer: &PeerId, io: &IoContext, data: UntrustedRlp) -> Result<(), Error> { const MAX_TRANSACTIONS: usize = 256; - let txs: Vec<_> = try!(data.iter().take(MAX_TRANSACTIONS).map(|x| x.as_val::()).collect()); + let txs: Vec<_> = data.iter() + .take(MAX_TRANSACTIONS) + .map(|x| x.as_val::()) + .collect::>()?; debug!(target: "les", "Received {} transactions to relay from peer {}", txs.len(), peer); diff --git a/ethcore/light/src/net/status.rs b/ethcore/light/src/net/status.rs index 90b8640cd..533d6b389 100644 --- a/ethcore/light/src/net/status.rs +++ b/ethcore/light/src/net/status.rs @@ -100,7 +100,7 @@ impl<'a> Parser<'a> { fn expect_raw(&mut self, key: Key) -> Result, DecoderError> { trace!(target: "les", "Expecting key {}", key.as_str()); let pre_pos = self.pos; - if let Some((k, val)) = try!(self.get_next()) { + if let Some((k, val)) = self.get_next()? { if k == key { return Ok(val) } } @@ -111,12 +111,12 @@ impl<'a> Parser<'a> { // get the next key and value RLP. fn get_next(&mut self) -> Result)>, DecoderError> { while self.pos < self.rlp.item_count() { - let pair = try!(self.rlp.at(self.pos)); - let k: String = try!(pair.val_at(0)); + let pair = self.rlp.at(self.pos)?; + let k: String = pair.val_at(0)?; self.pos += 1; match Key::from_str(&k) { - Some(key) => return Ok(Some((key , try!(pair.at(1))))), + Some(key) => return Ok(Some((key , pair.at(1)?))), None => continue, } } @@ -205,12 +205,12 @@ pub fn parse_handshake(rlp: UntrustedRlp) -> Result<(Status, Capabilities, Optio }; let status = Status { - protocol_version: try!(parser.expect(Key::ProtocolVersion)), - network_id: try!(parser.expect(Key::NetworkId)), - head_td: try!(parser.expect(Key::HeadTD)), - head_hash: try!(parser.expect(Key::HeadHash)), - head_num: try!(parser.expect(Key::HeadNum)), - genesis_hash: try!(parser.expect(Key::GenesisHash)), + protocol_version: parser.expect(Key::ProtocolVersion)?, + network_id: parser.expect(Key::NetworkId)?, + head_td: parser.expect(Key::HeadTD)?, + head_hash: parser.expect(Key::HeadHash)?, + head_num: parser.expect(Key::HeadNum)?, + genesis_hash: parser.expect(Key::GenesisHash)?, last_head: None, }; @@ -298,10 +298,10 @@ pub fn parse_announcement(rlp: UntrustedRlp) -> Result Result announcement.serve_headers = true, - Key::ServeStateSince => announcement.serve_state_since = Some(try!(item.as_val())), - Key::ServeChainSince => announcement.serve_chain_since = Some(try!(item.as_val())), + Key::ServeStateSince => announcement.serve_state_since = Some(item.as_val()?), + Key::ServeChainSince => announcement.serve_chain_since = Some(item.as_val()?), Key::TxRelay => announcement.tx_relay = true, _ => return Err(DecoderError::Custom("Nonsensical key in announcement")), } diff --git a/ethcore/src/account_provider/mod.rs b/ethcore/src/account_provider/mod.rs index dab19dbc0..5b56c697c 100644 --- a/ethcore/src/account_provider/mod.rs +++ b/ethcore/src/account_provider/mod.rs @@ -127,32 +127,32 @@ impl AccountProvider { let acc = Random.generate().expect("secp context has generation capabilities; qed"); let public = acc.public().clone(); let secret = acc.secret().clone(); - let address = try!(self.sstore.insert_account(secret, password)); + let address = self.sstore.insert_account(secret, password)?; Ok((address, public)) } /// Inserts new account into underlying store. /// Does not unlock account! pub fn insert_account(&self, secret: Secret, password: &str) -> Result { - let address = try!(self.sstore.insert_account(secret, password)); + let address = self.sstore.insert_account(secret, password)?; Ok(address) } /// Import a new presale wallet. pub fn import_presale(&self, presale_json: &[u8], password: &str) -> Result { - let address = try!(self.sstore.import_presale(presale_json, password)); + let address = self.sstore.import_presale(presale_json, password)?; Ok(Address::from(address).into()) } /// Import a new presale wallet. pub fn import_wallet(&self, json: &[u8], password: &str) -> Result { - let address = try!(self.sstore.import_wallet(json, password)); + let address = self.sstore.import_wallet(json, password)?; Ok(Address::from(address).into()) } /// Returns addresses of all accounts. pub fn accounts(&self) -> Result, Error> { - let accounts = try!(self.sstore.accounts()); + let accounts = self.sstore.accounts()?; Ok(accounts) } @@ -229,7 +229,7 @@ impl AccountProvider { /// Returns each account along with name and meta. pub fn accounts_info(&self) -> Result, Error> { - let r: HashMap = try!(self.sstore.accounts()) + let r: HashMap = self.sstore.accounts()? .into_iter() .map(|a| (a.clone(), self.account_meta(a).ok().unwrap_or_default())) .collect(); @@ -239,21 +239,21 @@ impl AccountProvider { /// Returns each account along with name and meta. pub fn account_meta(&self, account: Address) -> Result { Ok(AccountMeta { - name: try!(self.sstore.name(&account)), - meta: try!(self.sstore.meta(&account)), + name: self.sstore.name(&account)?, + meta: self.sstore.meta(&account)?, uuid: self.sstore.uuid(&account).ok().map(Into::into), // allowed to not have a Uuid }) } /// Returns each account along with name and meta. pub fn set_account_name(&self, account: Address, name: String) -> Result<(), Error> { - try!(self.sstore.set_name(&account, name)); + self.sstore.set_name(&account, name)?; Ok(()) } /// Returns each account along with name and meta. pub fn set_account_meta(&self, account: Address, meta: String) -> Result<(), Error> { - try!(self.sstore.set_meta(&account, meta)); + self.sstore.set_meta(&account, meta)?; Ok(()) } @@ -265,7 +265,7 @@ impl AccountProvider { /// Permanently removes an account. pub fn kill_account(&self, account: &Address, password: &str) -> Result<(), Error> { - try!(self.sstore.remove_account(account, &password)); + self.sstore.remove_account(account, &password)?; Ok(()) } @@ -278,7 +278,7 @@ impl AccountProvider { fn unlock_account(&self, account: Address, password: String, unlock: Unlock) -> Result<(), Error> { // verify password by signing dump message // result may be discarded - let _ = try!(self.sstore.sign(&account, &password, &Default::default())); + let _ = self.sstore.sign(&account, &password, &Default::default())?; // check if account is already unlocked pernamently, if it is, do nothing let mut unlocked = self.unlocked.write(); @@ -299,7 +299,7 @@ impl AccountProvider { fn password(&self, account: &Address) -> Result { let mut unlocked = self.unlocked.write(); - let data = try!(unlocked.get(account).ok_or(Error::NotUnlocked)).clone(); + let data = unlocked.get(account).ok_or(Error::NotUnlocked)?.clone(); if let Unlock::Temp = data.unlock { unlocked.remove(account).expect("data exists: so key must exist: qed"); } @@ -335,25 +335,25 @@ impl AccountProvider { /// Signs the message. If password is not provided the account must be unlocked. pub fn sign(&self, account: Address, password: Option, message: Message) -> Result { - let password = try!(password.map(Ok).unwrap_or_else(|| self.password(&account))); - Ok(try!(self.sstore.sign(&account, &password, &message))) + let password = password.map(Ok).unwrap_or_else(|| self.password(&account))?; + Ok(self.sstore.sign(&account, &password, &message)?) } /// Signs given message with supplied token. Returns a token to use in next signing within this session. pub fn sign_with_token(&self, account: Address, token: AccountToken, message: Message) -> Result<(Signature, AccountToken), Error> { - let is_std_password = try!(self.sstore.test_password(&account, &token)); + let is_std_password = self.sstore.test_password(&account, &token)?; let new_token = random_string(16); let signature = if is_std_password { // Insert to transient store - try!(self.sstore.copy_account(&self.transient_sstore, &account, &token, &new_token)); + self.sstore.copy_account(&self.transient_sstore, &account, &token, &new_token)?; // sign - try!(self.sstore.sign(&account, &token, &message)) + self.sstore.sign(&account, &token, &message)? } else { // check transient store - try!(self.transient_sstore.change_password(&account, &token, &new_token)); + self.transient_sstore.change_password(&account, &token, &new_token)?; // and sign - try!(self.transient_sstore.sign(&account, &new_token, &message)) + self.transient_sstore.sign(&account, &new_token, &message)? }; Ok((signature, new_token)) @@ -363,19 +363,19 @@ impl AccountProvider { pub fn decrypt_with_token(&self, account: Address, token: AccountToken, shared_mac: &[u8], message: &[u8]) -> Result<(Vec, AccountToken), Error> { - let is_std_password = try!(self.sstore.test_password(&account, &token)); + let is_std_password = self.sstore.test_password(&account, &token)?; let new_token = random_string(16); let message = if is_std_password { // Insert to transient store - try!(self.sstore.copy_account(&self.transient_sstore, &account, &token, &new_token)); + self.sstore.copy_account(&self.transient_sstore, &account, &token, &new_token)?; // decrypt - try!(self.sstore.decrypt(&account, &token, shared_mac, message)) + self.sstore.decrypt(&account, &token, shared_mac, message)? } else { // check transient store - try!(self.transient_sstore.change_password(&account, &token, &new_token)); + self.transient_sstore.change_password(&account, &token, &new_token)?; // and decrypt - try!(self.transient_sstore.decrypt(&account, &token, shared_mac, message)) + self.transient_sstore.decrypt(&account, &token, shared_mac, message)? }; Ok((message, new_token)) @@ -383,8 +383,8 @@ impl AccountProvider { /// Decrypts a message. If password is not provided the account must be unlocked. pub fn decrypt(&self, account: Address, password: Option, shared_mac: &[u8], message: &[u8]) -> Result, Error> { - let password = try!(password.map(Ok).unwrap_or_else(|| self.password(&account))); - Ok(try!(self.sstore.decrypt(&account, &password, shared_mac, message))) + let password = password.map(Ok).unwrap_or_else(|| self.password(&account))?; + Ok(self.sstore.decrypt(&account, &password, shared_mac, message)?) } /// Returns the underlying `SecretStore` reference if one exists. diff --git a/ethcore/src/block.rs b/ethcore/src/block.rs index 04fd556d7..1eec9110e 100644 --- a/ethcore/src/block.rs +++ b/ethcore/src/block.rs @@ -67,7 +67,7 @@ impl Block { impl Decodable for Block { fn decode(decoder: &D) -> Result where D: Decoder { - if decoder.as_raw().len() != try!(decoder.as_rlp().payload_info()).total() { + if decoder.as_raw().len() != decoder.as_rlp().payload_info()?.total() { return Err(DecoderError::RlpIsTooBig); } let d = decoder.as_rlp(); @@ -75,9 +75,9 @@ impl Decodable for Block { return Err(DecoderError::RlpIncorrectListLen); } Ok(Block { - header: try!(d.val_at(0)), - transactions: try!(d.val_at(1)), - uncles: try!(d.val_at(2)), + header: d.val_at(0)?, + transactions: d.val_at(1)?, + uncles: d.val_at(2)?, }) } } @@ -252,7 +252,7 @@ impl<'x> OpenBlock<'x> { gas_range_target: (U256, U256), extra_data: Bytes, ) -> Result { - let state = try!(State::from_existing(db, parent.state_root().clone(), engine.account_start_nonce(), factories)); + let state = State::from_existing(db, parent.state_root().clone(), engine.account_start_nonce(), factories)?; let mut r = OpenBlock { block: ExecutedBlock::new(state, tracing), engine: engine, @@ -521,12 +521,12 @@ pub fn enact( ) -> Result { { if ::log::max_log_level() >= ::log::LogLevel::Trace { - let s = try!(State::from_existing(db.boxed_clone(), parent.state_root().clone(), engine.account_start_nonce(), factories.clone())); + let s = State::from_existing(db.boxed_clone(), parent.state_root().clone(), engine.account_start_nonce(), factories.clone())?; trace!(target: "enact", "num={}, root={}, author={}, author_balance={}\n", header.number(), s.root(), header.author(), s.balance(&header.author())); } } - let mut b = try!(OpenBlock::new(engine, factories, tracing, db, parent, last_hashes, Address::new(), (3141562.into(), 31415620.into()), vec![])); + let mut b = OpenBlock::new(engine, factories, tracing, db, parent, last_hashes, Address::new(), (3141562.into(), 31415620.into()), vec![])?; b.set_difficulty(*header.difficulty()); b.set_gas_limit(*header.gas_limit()); b.set_timestamp(header.timestamp()); @@ -536,9 +536,9 @@ pub fn enact( b.set_transactions_root(header.transactions_root().clone()); b.set_receipts_root(header.receipts_root().clone()); - try!(push_transactions(&mut b, transactions)); + push_transactions(&mut b, transactions)?; for u in uncles { - try!(b.push_uncle(u.clone())); + b.push_uncle(u.clone())?; } Ok(b.close_and_lock()) } @@ -547,7 +547,7 @@ pub fn enact( #[cfg(not(feature = "slow-blocks"))] fn push_transactions(block: &mut OpenBlock, transactions: &[SignedTransaction]) -> Result<(), Error> { for t in transactions { - try!(block.push_transaction(t.clone(), None)); + block.push_transaction(t.clone(), None)?; } Ok(()) } @@ -560,7 +560,7 @@ fn push_transactions(block: &mut OpenBlock, transactions: &[SignedTransaction]) for t in transactions { let hash = t.hash(); let start = time::Instant::now(); - try!(block.push_transaction(t.clone(), None)); + block.push_transaction(t.clone(), None)?; let took = start.elapsed(); if took > time::Duration::from_millis(slow_tx) { warn!("Heavy transaction in block {:?}: {:?}", block.header().number(), hash); @@ -627,7 +627,7 @@ mod tests { factories: Factories, ) -> Result { let header = BlockView::new(block_bytes).header_view(); - Ok(try!(try!(enact_bytes(block_bytes, engine, tracing, db, parent, last_hashes, factories)).seal(engine, header.seal()))) + Ok(enact_bytes(block_bytes, engine, tracing, db, parent, last_hashes, factories)?.seal(engine, header.seal())?) } #[test] diff --git a/ethcore/src/blockchain/extras.rs b/ethcore/src/blockchain/extras.rs index bf32258f9..98cc137ed 100644 --- a/ethcore/src/blockchain/extras.rs +++ b/ethcore/src/blockchain/extras.rs @@ -157,10 +157,10 @@ impl Decodable for BlockDetails { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); let details = BlockDetails { - number: try!(d.val_at(0)), - total_difficulty: try!(d.val_at(1)), - parent: try!(d.val_at(2)), - children: try!(d.val_at(3)), + number: d.val_at(0)?, + total_difficulty: d.val_at(1)?, + parent: d.val_at(2)?, + children: d.val_at(3)?, }; Ok(details) } @@ -193,8 +193,8 @@ impl Decodable for TransactionAddress { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); let tx_address = TransactionAddress { - block_hash: try!(d.val_at(0)), - index: try!(d.val_at(1)), + block_hash: d.val_at(0)?, + index: d.val_at(1)?, }; Ok(tx_address) @@ -226,7 +226,7 @@ impl BlockReceipts { impl Decodable for BlockReceipts { fn decode(decoder: &D) -> Result where D: Decoder { Ok(BlockReceipts { - receipts: try!(Decodable::decode(decoder)) + receipts: Decodable::decode(decoder)? }) } } diff --git a/ethcore/src/blooms/bloom_group.rs b/ethcore/src/blooms/bloom_group.rs index 2dbc4e455..435819c94 100644 --- a/ethcore/src/blooms/bloom_group.rs +++ b/ethcore/src/blooms/bloom_group.rs @@ -53,7 +53,7 @@ impl Into for BloomGroup { impl Decodable for BloomGroup { fn decode(decoder: &D) -> Result where D: Decoder { - let blooms = try!(Decodable::decode(decoder)); + let blooms = Decodable::decode(decoder)?; let group = BloomGroup { blooms: blooms }; diff --git a/ethcore/src/client/client.rs b/ethcore/src/client/client.rs index c46f477b1..cfe5dc527 100644 --- a/ethcore/src/client/client.rs +++ b/ethcore/src/client/client.rs @@ -167,7 +167,7 @@ impl Client { ) -> Result, ClientError> { let path = path.to_path_buf(); - let db = Arc::new(try!(Database::open(&db_config, &path.to_str().expect("DB path could not be converted to string.")).map_err(ClientError::Database))); + let db = Arc::new(Database::open(&db_config, &path.to_str().expect("DB path could not be converted to string.")).map_err(ClientError::Database)?); let trie_spec = match config.fat_db { true => TrieSpec::Fat, false => TrieSpec::Secure, @@ -186,8 +186,8 @@ impl Client { // Sets the correct state root. state_db = spec.ensure_db_good(state_db, &factories)?; let mut batch = DBTransaction::new(&db); - try!(state_db.journal_under(&mut batch, 0, &spec.genesis_header().hash())); - try!(db.write(batch).map_err(ClientError::Database)); + state_db.journal_under(&mut batch, 0, &spec.genesis_header().hash())?; + db.write(batch).map_err(ClientError::Database)?; } let gb = spec.genesis_block(); @@ -210,8 +210,8 @@ impl Client { for era in earliest..(latest - history + 1) { trace!("Removing era {}", era); let mut batch = DBTransaction::new(&db); - try!(state_db.mark_canonical(&mut batch, era, &chain.block_hash(era).expect("Old block not found in the database"))); - try!(db.write(batch).map_err(ClientError::Database)); + state_db.mark_canonical(&mut batch, era, &chain.block_hash(era).expect("Old block not found in the database"))?; + db.write(batch).map_err(ClientError::Database)?; } } } @@ -252,7 +252,7 @@ impl Client { last_hashes: RwLock::new(VecDeque::new()), factories: factories, history: history, - rng: Mutex::new(try!(OsRng::new().map_err(::util::UtilError::StdIo))), + rng: Mutex::new(OsRng::new().map_err(::util::UtilError::StdIo)?), on_mode_change: Mutex::new(None), registrar: Mutex::new(None), }); @@ -370,9 +370,9 @@ impl Client { let db = self.state_db.lock().boxed_clone_canon(header.parent_hash()); let enact_result = enact_verified(block, engine, self.tracedb.read().tracing_enabled(), db, &parent, last_hashes, self.factories.clone()); - let locked_block = try!(enact_result.map_err(|e| { + let locked_block = enact_result.map_err(|e| { warn!(target: "client", "Block import failed for #{} ({})\nError: {:?}", header.number(), header.hash(), e); - })); + })?; // Final Verification if let Err(e) = self.verifier.verify_block_final(header, locked_block.block().header()) { @@ -511,14 +511,14 @@ impl Client { let chain = self.chain.read(); // verify block. - try!(::snapshot::verify_old_block( + ::snapshot::verify_old_block( &mut *rng, &header, &*self.engine, &*chain, Some(&block_bytes), false, - )); + )?; // Commit results let receipts = ::rlp::decode(&receipts_bytes); @@ -739,7 +739,7 @@ impl Client { pub fn take_snapshot(&self, writer: W, at: BlockId, p: &snapshot::Progress) -> Result<(), EthcoreError> { let db = self.state_db.lock().journal_db().boxed_clone(); let best_block_number = self.chain_info().best_block_number; - let block_number = try!(self.block_number(at).ok_or(snapshot::Error::InvalidStartingBlock(at))); + let block_number = self.block_number(at).ok_or(snapshot::Error::InvalidStartingBlock(at))?; if best_block_number > self.history + block_number && db.is_pruned() { return Err(snapshot::Error::OldBlockPrunedDB.into()); @@ -765,7 +765,7 @@ impl Client { }, }; - try!(snapshot::take_snapshot(&self.chain.read(), start_hash, db.as_hashdb(), writer, p)); + snapshot::take_snapshot(&self.chain.read(), start_hash, db.as_hashdb(), writer, p)?; Ok(()) } @@ -829,7 +829,7 @@ impl snapshot::DatabaseRestore for Client { let mut tracedb = self.tracedb.write(); self.miner.clear(); let db = self.db.write(); - try!(db.restore(new_db)); + db.restore(new_db)?; let cache_size = state_db.cache_size(); *state_db = StateDB::new(journaldb::new(db.clone(), self.pruning, ::db::COL_STATE), cache_size); @@ -842,7 +842,7 @@ impl snapshot::DatabaseRestore for Client { impl BlockChainClient for Client { fn call(&self, t: &SignedTransaction, block: BlockId, analytics: CallAnalytics) -> Result { - let header = try!(self.block_header(block).ok_or(CallError::StatePruned)); + let header = self.block_header(block).ok_or(CallError::StatePruned)?; let view = HeaderView::new(&header); let last_hashes = self.build_last_hashes(view.parent_hash()); let env_info = EnvInfo { @@ -855,13 +855,13 @@ impl BlockChainClient for Client { gas_limit: U256::max_value(), }; // that's just a copy of the state. - let mut state = try!(self.state_at(block).ok_or(CallError::StatePruned)); + let mut state = self.state_at(block).ok_or(CallError::StatePruned)?; let original_state = if analytics.state_diffing { Some(state.clone()) } else { None }; - let sender = try!(t.sender().map_err(|e| { + let sender = t.sender().map_err(|e| { let message = format!("Transaction malformed: {:?}", e); ExecutionError::TransactionMalformed(message) - })); + })?; let balance = state.balance(&sender); let needed_balance = t.value + t.gas * t.gas_price; if balance < needed_balance { @@ -869,7 +869,7 @@ impl BlockChainClient for Client { state.add_balance(&sender, &(needed_balance - balance), CleanupMode::NoEmpty); } let options = TransactOptions { tracing: analytics.transaction_tracing, vm_tracing: analytics.vm_tracing, check_nonce: false }; - let mut ret = try!(Executive::new(&mut state, &env_info, &*self.engine, &self.factories.vm).transact(t, options)); + let mut ret = Executive::new(&mut state, &env_info, &*self.engine, &self.factories.vm).transact(t, options)?; // TODO gav move this into Executive. ret.state_diff = original_state.map(|original| state.diff_from(original)); @@ -878,10 +878,10 @@ impl BlockChainClient for Client { } fn replay(&self, id: TransactionId, analytics: CallAnalytics) -> Result { - let address = try!(self.transaction_address(id).ok_or(CallError::TransactionNotFound)); - let header_data = try!(self.block_header(BlockId::Hash(address.block_hash)).ok_or(CallError::StatePruned)); - let body_data = try!(self.block_body(BlockId::Hash(address.block_hash)).ok_or(CallError::StatePruned)); - let mut state = try!(self.state_at_beginning(BlockId::Hash(address.block_hash)).ok_or(CallError::StatePruned)); + let address = self.transaction_address(id).ok_or(CallError::TransactionNotFound)?; + let header_data = self.block_header(BlockId::Hash(address.block_hash)).ok_or(CallError::StatePruned)?; + let body_data = self.block_body(BlockId::Hash(address.block_hash)).ok_or(CallError::StatePruned)?; + let mut state = self.state_at_beginning(BlockId::Hash(address.block_hash)).ok_or(CallError::StatePruned)?; let txs = BodyView::new(&body_data).transactions(); if address.index >= txs.len() { @@ -909,7 +909,7 @@ impl BlockChainClient for Client { let t = &txs[address.index]; let original_state = if analytics.state_diffing { Some(state.clone()) } else { None }; - let mut ret = try!(Executive::new(&mut state, &env_info, &*self.engine, &self.factories.vm).transact(t, options)); + let mut ret = Executive::new(&mut state, &env_info, &*self.engine, &self.factories.vm).transact(t, options)?; ret.state_diff = original_state.map(|original| state.diff_from(original)); Ok(ret) @@ -1221,7 +1221,7 @@ impl BlockChainClient for Client { return Err(BlockImportError::Block(BlockError::UnknownParent(unverified.parent_hash()))); } } - Ok(try!(self.block_queue.import(unverified))) + Ok(self.block_queue.import(unverified)?) } fn import_block_with_receipts(&self, block_bytes: Bytes, receipts_bytes: Bytes) -> Result { diff --git a/ethcore/src/client/registry.rs b/ethcore/src/client/registry.rs index 7693feaeb..9e60a1251 100644 --- a/ethcore/src/client/registry.rs +++ b/ethcore/src/client/registry.rs @@ -43,7 +43,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bool().ok_or("Invalid type returned")); r })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bool().ok_or("Invalid type returned")?; r })) } /// Auto-generated from: `{"constant":false,"inputs":[{"name":"_name","type":"bytes32"}],"name":"reserve","outputs":[{"name":"success","type":"bool"}],"payable":false,"type":"function"}` @@ -55,7 +55,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bool().ok_or("Invalid type returned")); r })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bool().ok_or("Invalid type returned")?; r })) } /// Auto-generated from: `{"constant":false,"inputs":[{"name":"_name","type":"bytes32"},{"name":"_key","type":"string"},{"name":"_value","type":"bytes32"}],"name":"set","outputs":[{"name":"success","type":"bool"}],"payable":false,"type":"function"}` @@ -67,7 +67,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bool().ok_or("Invalid type returned")); r })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bool().ok_or("Invalid type returned")?; r })) } /// Auto-generated from: `{"constant":false,"inputs":[{"name":"_name","type":"bytes32"}],"name":"drop","outputs":[{"name":"success","type":"bool"}],"payable":false,"type":"function"}` @@ -79,7 +79,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bool().ok_or("Invalid type returned")); r })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bool().ok_or("Invalid type returned")?; r })) } /// Auto-generated from: `{"constant":true,"inputs":[{"name":"_name","type":"bytes32"},{"name":"_key","type":"string"}],"name":"getAddress","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"}` @@ -91,7 +91,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_address().ok_or("Invalid type returned")); util::Address::from(r) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_address().ok_or("Invalid type returned")?; util::Address::from(r) })) } /// Auto-generated from: `{"constant":false,"inputs":[{"name":"_amount","type":"uint256"}],"name":"setFee","outputs":[],"payable":false,"type":"function"}` @@ -115,7 +115,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bool().ok_or("Invalid type returned")); r })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bool().ok_or("Invalid type returned")?; r })) } /// Auto-generated from: `{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"}` @@ -127,7 +127,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_address().ok_or("Invalid type returned")); util::Address::from(r) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_address().ok_or("Invalid type returned")?; util::Address::from(r) })) } /// Auto-generated from: `{"constant":true,"inputs":[{"name":"_name","type":"bytes32"}],"name":"reserved","outputs":[{"name":"reserved","type":"bool"}],"payable":false,"type":"function"}` @@ -139,7 +139,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bool().ok_or("Invalid type returned")); r })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bool().ok_or("Invalid type returned")?; r })) } /// Auto-generated from: `{"constant":false,"inputs":[],"name":"drain","outputs":[],"payable":false,"type":"function"}` @@ -163,7 +163,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bool().ok_or("Invalid type returned")); r })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bool().ok_or("Invalid type returned")?; r })) } /// Auto-generated from: `{"constant":true,"inputs":[{"name":"_name","type":"bytes32"},{"name":"_key","type":"string"}],"name":"getUint","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"}` @@ -175,7 +175,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()) })) } /// Auto-generated from: `{"constant":true,"inputs":[{"name":"_name","type":"bytes32"},{"name":"_key","type":"string"}],"name":"get","outputs":[{"name":"","type":"bytes32"}],"payable":false,"type":"function"}` @@ -187,7 +187,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_fixed_bytes().ok_or("Invalid type returned")); util::H256::from_slice(r.as_ref()) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_fixed_bytes().ok_or("Invalid type returned")?; util::H256::from_slice(r.as_ref()) })) } /// Auto-generated from: `{"constant":true,"inputs":[],"name":"fee","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"}` @@ -199,7 +199,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()) })) } /// Auto-generated from: `{"constant":true,"inputs":[{"name":"_name","type":"bytes32"}],"name":"getOwner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"}` @@ -211,7 +211,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_address().ok_or("Invalid type returned")); util::Address::from(r) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_address().ok_or("Invalid type returned")?; util::Address::from(r) })) } /// Auto-generated from: `{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"reverse","outputs":[{"name":"","type":"string"}],"payable":false,"type":"function"}` @@ -223,7 +223,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_string().ok_or("Invalid type returned")); r })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_string().ok_or("Invalid type returned")?; r })) } /// Auto-generated from: `{"constant":false,"inputs":[{"name":"_name","type":"bytes32"},{"name":"_key","type":"string"},{"name":"_value","type":"uint256"}],"name":"setUint","outputs":[{"name":"success","type":"bool"}],"payable":false,"type":"function"}` @@ -235,7 +235,7 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bool().ok_or("Invalid type returned")); r })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bool().ok_or("Invalid type returned")?; r })) } /// Auto-generated from: `{"constant":false,"inputs":[],"name":"removeReverse","outputs":[],"payable":false,"type":"function"}` @@ -259,6 +259,6 @@ impl Registry { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bool().ok_or("Invalid type returned")); r })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bool().ok_or("Invalid type returned")?; r })) } } \ No newline at end of file diff --git a/ethcore/src/engines/authority_round.rs b/ethcore/src/engines/authority_round.rs index f94fb3a0e..72dacddf4 100644 --- a/ethcore/src/engines/authority_round.rs +++ b/ethcore/src/engines/authority_round.rs @@ -107,7 +107,7 @@ impl AuthorityRound { params: params, our_params: our_params, builtins: builtins, - transition_service: try!(IoService::<()>::start()), + transition_service: IoService::<()>::start()?, message_channel: Mutex::new(None), step: AtomicUsize::new(initial_step), proposed: AtomicBool::new(false), @@ -117,7 +117,7 @@ impl AuthorityRound { // Do not initialize timeouts for tests. if should_timeout { let handler = TransitionHandler { engine: Arc::downgrade(&engine) }; - try!(engine.transition_service.register_handler(Arc::new(handler))); + engine.transition_service.register_handler(Arc::new(handler))?; } Ok(engine) } @@ -263,20 +263,20 @@ impl Engine for AuthorityRound { /// Check if the signature belongs to the correct proposer. fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> { - let header_step = try!(header_step(header)); + let header_step = header_step(header)?; // Give one step slack if step is lagging, double vote is still not possible. if header_step <= self.step.load(AtomicOrdering::SeqCst) + 1 { - let proposer_signature = try!(header_signature(header)); - let ok_sig = try!(verify_address(self.step_proposer(header_step), &proposer_signature, &header.bare_hash())); + let proposer_signature = header_signature(header)?; + let ok_sig = verify_address(self.step_proposer(header_step), &proposer_signature, &header.bare_hash())?; if ok_sig { Ok(()) } else { trace!(target: "poa", "verify_block_unordered: invalid seal signature"); - try!(Err(BlockError::InvalidSeal)) + Err(BlockError::InvalidSeal)? } } else { trace!(target: "poa", "verify_block_unordered: block from the future"); - try!(Err(BlockError::InvalidSeal)) + Err(BlockError::InvalidSeal)? } } @@ -285,11 +285,11 @@ impl Engine for AuthorityRound { return Err(From::from(BlockError::RidiculousNumber(OutOfBounds { min: Some(1), max: None, found: header.number() }))); } - let step = try!(header_step(header)); + let step = header_step(header)?; // Check if parent is from a previous step. - if step == try!(header_step(parent)) { + if step == header_step(parent)? { trace!(target: "poa", "Multiple blocks proposed for step {}.", step); - try!(Err(EngineError::DoubleVote(header.author().clone()))); + Err(EngineError::DoubleVote(header.author().clone()))?; } let gas_limit_divisor = self.our_params.gas_limit_bound_divisor; @@ -302,7 +302,7 @@ impl Engine for AuthorityRound { } fn verify_transaction_basic(&self, t: &SignedTransaction, _header: &Header) -> Result<(), Error> { - try!(t.check_low_s()); + t.check_low_s()?; Ok(()) } diff --git a/ethcore/src/engines/basic_authority.rs b/ethcore/src/engines/basic_authority.rs index fe8336886..8112a574e 100644 --- a/ethcore/src/engines/basic_authority.rs +++ b/ethcore/src/engines/basic_authority.rs @@ -143,10 +143,10 @@ impl Engine for BasicAuthority { use rlp::{UntrustedRlp, View}; // check the signature is legit. - let sig = try!(UntrustedRlp::new(&header.seal()[0]).as_val::()); - let signer = public_to_address(&try!(recover(&sig.into(), &header.bare_hash()))); + let sig = UntrustedRlp::new(&header.seal()[0]).as_val::()?; + let signer = public_to_address(&recover(&sig.into(), &header.bare_hash())?); if !self.our_params.authorities.contains(&signer) { - return try!(Err(BlockError::InvalidSeal)); + return Err(BlockError::InvalidSeal)?; } Ok(()) } @@ -171,7 +171,7 @@ impl Engine for BasicAuthority { } fn verify_transaction_basic(&self, t: &SignedTransaction, _header: &Header) -> result::Result<(), Error> { - try!(t.check_low_s()); + t.check_low_s()?; Ok(()) } diff --git a/ethcore/src/engines/tendermint/message.rs b/ethcore/src/engines/tendermint/message.rs index 3e5da592d..02e1276cf 100644 --- a/ethcore/src/engines/tendermint/message.rs +++ b/ethcore/src/engines/tendermint/message.rs @@ -51,9 +51,9 @@ impl ConsensusMessage { pub fn new_proposal(header: &Header) -> Result { Ok(ConsensusMessage { - signature: try!(UntrustedRlp::new(header.seal().get(1).expect("seal passed basic verification; seal has 3 fields; qed").as_slice()).as_val()), + signature: UntrustedRlp::new(header.seal().get(1).expect("seal passed basic verification; seal has 3 fields; qed").as_slice()).as_val()?, height: header.number() as Height, - round: try!(consensus_round(header)), + round: consensus_round(header)?, step: Step::Propose, block_hash: Some(header.bare_hash()), }) @@ -92,7 +92,7 @@ impl ConsensusMessage { pub fn verify(&self) -> Result { let full_rlp = ::rlp::encode(self); let block_info = Rlp::new(&full_rlp).at(1); - let public_key = try!(recover(&self.signature.into(), &block_info.as_raw().sha3())); + let public_key = recover(&self.signature.into(), &block_info.as_raw().sha3())?; Ok(public_to_address(&public_key)) } @@ -134,7 +134,7 @@ impl Ord for ConsensusMessage { impl Decodable for Step { fn decode(decoder: &D) -> Result where D: Decoder { - match try!(decoder.as_rlp().as_val()) { + match decoder.as_rlp().as_val()? { 0u8 => Ok(Step::Propose), 1 => Ok(Step::Prevote), 2 => Ok(Step::Precommit), @@ -153,13 +153,13 @@ impl Encodable for Step { impl Decodable for ConsensusMessage { fn decode(decoder: &D) -> Result where D: Decoder { let rlp = decoder.as_rlp(); - let m = try!(rlp.at(1)); - let block_message: H256 = try!(m.val_at(3)); + let m = rlp.at(1)?; + let block_message: H256 = m.val_at(3)?; Ok(ConsensusMessage { - signature: try!(rlp.val_at(0)), - height: try!(m.val_at(0)), - round: try!(m.val_at(1)), - step: try!(m.val_at(2)), + signature: rlp.val_at(0)?, + height: m.val_at(0)?, + round: m.val_at(1)?, + step: m.val_at(2)?, block_hash: match block_message.is_zero() { true => None, false => Some(block_message), diff --git a/ethcore/src/engines/tendermint/mod.rs b/ethcore/src/engines/tendermint/mod.rs index ffbc40cc3..e124445e9 100644 --- a/ethcore/src/engines/tendermint/mod.rs +++ b/ethcore/src/engines/tendermint/mod.rs @@ -109,7 +109,7 @@ impl Tendermint { params: params, our_params: our_params, builtins: builtins, - step_service: try!(IoService::::start()), + step_service: IoService::::start()?, authority: RwLock::new(Address::default()), password: RwLock::new(None), height: AtomicUsize::new(1), @@ -123,7 +123,7 @@ impl Tendermint { proposal: RwLock::new(None), }); let handler = TransitionHandler { engine: Arc::downgrade(&engine) }; - try!(engine.step_service.register_handler(Arc::new(handler))); + engine.step_service.register_handler(Arc::new(handler))?; Ok(engine) } @@ -455,11 +455,11 @@ impl Engine for Tendermint { fn handle_message(&self, rlp: &[u8]) -> Result<(), Error> { let rlp = UntrustedRlp::new(rlp); - let message: ConsensusMessage = try!(rlp.as_val()); + let message: ConsensusMessage = rlp.as_val()?; if !self.votes.is_old_or_known(&message) { - let sender = public_to_address(&try!(recover(&message.signature.into(), &try!(rlp.at(1)).as_raw().sha3()))); + let sender = public_to_address(&recover(&message.signature.into(), &rlp.at(1)?.as_raw().sha3())?); if !self.is_authority(&sender) { - try!(Err(EngineError::NotAuthorized(sender))); + Err(EngineError::NotAuthorized(sender))?; } self.broadcast_message(rlp.as_raw().to_vec()); trace!(target: "poa", "Handling a valid {:?} from {}.", message, sender); @@ -491,10 +491,10 @@ impl Engine for Tendermint { } fn verify_block_unordered(&self, header: &Header, _block: Option<&[u8]>) -> Result<(), Error> { - let proposal = try!(ConsensusMessage::new_proposal(header)); - let proposer = try!(proposal.verify()); + let proposal = ConsensusMessage::new_proposal(header)?; + let proposer = proposal.verify()?; if !self.is_authority(&proposer) { - try!(Err(EngineError::NotAuthorized(proposer))) + Err(EngineError::NotAuthorized(proposer))? } let precommit_hash = proposal.precommit_hash(); @@ -502,20 +502,20 @@ impl Engine for Tendermint { let mut signature_count = 0; let mut origins = HashSet::new(); for rlp in UntrustedRlp::new(signatures_field).iter() { - let precommit: ConsensusMessage = ConsensusMessage::new_commit(&proposal, try!(rlp.as_val())); + let precommit: ConsensusMessage = ConsensusMessage::new_commit(&proposal, rlp.as_val()?); let address = match self.votes.get(&precommit) { Some(a) => a, - None => public_to_address(&try!(recover(&precommit.signature.into(), &precommit_hash))), + None => public_to_address(&recover(&precommit.signature.into(), &precommit_hash)?), }; if !self.our_params.authorities.contains(&address) { - try!(Err(EngineError::NotAuthorized(address.to_owned()))) + Err(EngineError::NotAuthorized(address.to_owned()))? } if origins.insert(address) { signature_count += 1; } else { warn!(target: "poa", "verify_block_unordered: Duplicate signature from {} on the seal.", address); - try!(Err(BlockError::InvalidSeal)); + Err(BlockError::InvalidSeal)?; } } @@ -524,34 +524,34 @@ impl Engine for Tendermint { let signatures_len = signatures_field.len(); // Proposal has to have an empty signature list. if signatures_len != 1 { - try!(Err(EngineError::BadSealFieldSize(OutOfBounds { + Err(EngineError::BadSealFieldSize(OutOfBounds { min: Some(1), max: Some(1), found: signatures_len - }))); + }))?; } - try!(self.is_round_proposer(proposal.height, proposal.round, &proposer)); + self.is_round_proposer(proposal.height, proposal.round, &proposer)?; } Ok(()) } fn verify_block_family(&self, header: &Header, parent: &Header, _block: Option<&[u8]>) -> Result<(), Error> { if header.number() == 0 { - try!(Err(BlockError::RidiculousNumber(OutOfBounds { min: Some(1), max: None, found: header.number() }))); + Err(BlockError::RidiculousNumber(OutOfBounds { min: Some(1), max: None, found: header.number() }))?; } let gas_limit_divisor = self.our_params.gas_limit_bound_divisor; let min_gas = parent.gas_limit().clone() - parent.gas_limit().clone() / gas_limit_divisor; let max_gas = parent.gas_limit().clone() + parent.gas_limit().clone() / gas_limit_divisor; if header.gas_limit() <= &min_gas || header.gas_limit() >= &max_gas { - try!(Err(BlockError::InvalidGasLimit(OutOfBounds { min: Some(min_gas), max: Some(max_gas), found: header.gas_limit().clone() }))); + Err(BlockError::InvalidGasLimit(OutOfBounds { min: Some(min_gas), max: Some(max_gas), found: header.gas_limit().clone() }))?; } Ok(()) } fn verify_transaction_basic(&self, t: &SignedTransaction, _header: &Header) -> Result<(), Error> { - try!(t.check_low_s()); + t.check_low_s()?; Ok(()) } diff --git a/ethcore/src/ethereum/ethash.rs b/ethcore/src/ethereum/ethash.rs index 1535f9783..909480570 100644 --- a/ethcore/src/ethereum/ethash.rs +++ b/ethcore/src/ethereum/ethash.rs @@ -240,8 +240,8 @@ impl Engine for Ethash { Mismatch { expected: self.seal_fields(), found: header.seal().len() } ))); } - try!(UntrustedRlp::new(&header.seal()[0]).as_val::()); - try!(UntrustedRlp::new(&header.seal()[1]).as_val::()); + UntrustedRlp::new(&header.seal()[0]).as_val::()?; + UntrustedRlp::new(&header.seal()[1]).as_val::()?; // TODO: consider removing these lines. let min_difficulty = self.ethash_params.minimum_difficulty; @@ -312,7 +312,7 @@ impl Engine for Ethash { fn verify_transaction_basic(&self, t: &SignedTransaction, header: &Header) -> result::Result<(), Error> { if header.number() >= self.ethash_params.homestead_transition { - try!(t.check_low_s()); + t.check_low_s()?; } if let Some(n) = t.network_id() { diff --git a/ethcore/src/evm/interpreter/gasometer.rs b/ethcore/src/evm/interpreter/gasometer.rs index 28a2ee9b4..851f6c012 100644 --- a/ethcore/src/evm/interpreter/gasometer.rs +++ b/ethcore/src/evm/interpreter/gasometer.rs @@ -159,39 +159,39 @@ impl Gasometer { Request::Gas(gas) }, instructions::MSTORE | instructions::MLOAD => { - Request::GasMem(default_gas, try!(mem_needed_const(stack.peek(0), 32))) + Request::GasMem(default_gas, mem_needed_const(stack.peek(0), 32)?) }, instructions::MSTORE8 => { - Request::GasMem(default_gas, try!(mem_needed_const(stack.peek(0), 1))) + Request::GasMem(default_gas, mem_needed_const(stack.peek(0), 1)?) }, instructions::RETURN => { - Request::GasMem(default_gas, try!(mem_needed(stack.peek(0), stack.peek(1)))) + Request::GasMem(default_gas, mem_needed(stack.peek(0), stack.peek(1))?) }, instructions::SHA3 => { - let w = overflowing!(add_gas_usize(try!(Gas::from_u256(*stack.peek(1))), 31)); + let w = overflowing!(add_gas_usize(Gas::from_u256(*stack.peek(1))?, 31)); let words = w >> 5; let gas = Gas::from(schedule.sha3_gas) + (Gas::from(schedule.sha3_word_gas) * words); - Request::GasMem(gas, try!(mem_needed(stack.peek(0), stack.peek(1)))) + Request::GasMem(gas, mem_needed(stack.peek(0), stack.peek(1))?) }, instructions::CALLDATACOPY | instructions::CODECOPY => { - Request::GasMemCopy(default_gas, try!(mem_needed(stack.peek(0), stack.peek(2))), try!(Gas::from_u256(*stack.peek(2)))) + Request::GasMemCopy(default_gas, mem_needed(stack.peek(0), stack.peek(2))?, Gas::from_u256(*stack.peek(2))?) }, instructions::EXTCODECOPY => { - Request::GasMemCopy(schedule.extcodecopy_base_gas.into(), try!(mem_needed(stack.peek(1), stack.peek(3))), try!(Gas::from_u256(*stack.peek(3)))) + Request::GasMemCopy(schedule.extcodecopy_base_gas.into(), mem_needed(stack.peek(1), stack.peek(3))?, Gas::from_u256(*stack.peek(3))?) }, instructions::LOG0...instructions::LOG4 => { let no_of_topics = instructions::get_log_topics(instruction); let log_gas = schedule.log_gas + schedule.log_topic_gas * no_of_topics; - let data_gas = overflowing!(try!(Gas::from_u256(*stack.peek(1))).overflow_mul(Gas::from(schedule.log_data_gas))); + let data_gas = overflowing!(Gas::from_u256(*stack.peek(1))?.overflow_mul(Gas::from(schedule.log_data_gas))); let gas = overflowing!(data_gas.overflow_add(Gas::from(log_gas))); - Request::GasMem(gas, try!(mem_needed(stack.peek(0), stack.peek(1)))) + Request::GasMem(gas, mem_needed(stack.peek(0), stack.peek(1))?) }, instructions::CALL | instructions::CALLCODE => { let mut gas = Gas::from(schedule.call_gas); let mem = cmp::max( - try!(mem_needed(stack.peek(5), stack.peek(6))), - try!(mem_needed(stack.peek(3), stack.peek(4))) + mem_needed(stack.peek(5), stack.peek(6))?, + mem_needed(stack.peek(3), stack.peek(4))? ); let address = u256_to_address(stack.peek(1)); @@ -216,8 +216,8 @@ impl Gasometer { instructions::DELEGATECALL => { let gas = Gas::from(schedule.call_gas); let mem = cmp::max( - try!(mem_needed(stack.peek(4), stack.peek(5))), - try!(mem_needed(stack.peek(2), stack.peek(3))) + mem_needed(stack.peek(4), stack.peek(5))?, + mem_needed(stack.peek(2), stack.peek(3))? ); let requested = *stack.peek(0); @@ -225,7 +225,7 @@ impl Gasometer { }, instructions::CREATE => { let gas = Gas::from(schedule.create_gas); - let mem = try!(mem_needed(stack.peek(1), stack.peek(2))); + let mem = mem_needed(stack.peek(1), stack.peek(2))?; Request::GasMemProvide(gas, mem, None) }, @@ -248,7 +248,7 @@ impl Gasometer { } }, Request::GasMem(gas, mem_size) => { - let (mem_gas_cost, new_mem_gas, new_mem_size) = try!(self.mem_gas_cost(schedule, current_mem_size, &mem_size)); + let (mem_gas_cost, new_mem_gas, new_mem_size) = self.mem_gas_cost(schedule, current_mem_size, &mem_size)?; let gas = overflowing!(gas.overflow_add(mem_gas_cost)); InstructionRequirements { gas_cost: gas, @@ -258,9 +258,9 @@ impl Gasometer { } }, Request::GasMemProvide(gas, mem_size, requested) => { - let (mem_gas_cost, new_mem_gas, new_mem_size) = try!(self.mem_gas_cost(schedule, current_mem_size, &mem_size)); + let (mem_gas_cost, new_mem_gas, new_mem_size) = self.mem_gas_cost(schedule, current_mem_size, &mem_size)?; let gas = overflowing!(gas.overflow_add(mem_gas_cost)); - let provided = try!(self.gas_provided(schedule, gas, requested)); + let provided = self.gas_provided(schedule, gas, requested)?; let total_gas = overflowing!(gas.overflow_add(provided)); InstructionRequirements { @@ -271,7 +271,7 @@ impl Gasometer { } }, Request::GasMemCopy(gas, mem_size, copy) => { - let (mem_gas_cost, new_mem_gas, new_mem_size) = try!(self.mem_gas_cost(schedule, current_mem_size, &mem_size)); + let (mem_gas_cost, new_mem_gas, new_mem_size) = self.mem_gas_cost(schedule, current_mem_size, &mem_size)?; let copy = overflowing!(add_gas_usize(copy, 31)) >> 5; let copy_gas = Gas::from(schedule.copy_gas) * copy; let gas = overflowing!(gas.overflow_add(copy_gas)); @@ -303,7 +303,7 @@ impl Gasometer { let req_mem_size_rounded = (overflowing!(mem_size.overflow_add(Gas::from(31 as usize))) >> 5) << 5; let (mem_gas_cost, new_mem_gas) = if req_mem_size_rounded > current_mem_size { - let new_mem_gas = try!(gas_for_mem(req_mem_size_rounded)); + let new_mem_gas = gas_for_mem(req_mem_size_rounded)?; (new_mem_gas - self.current_mem_gas, new_mem_gas) } else { (Gas::from(0), self.current_mem_gas) diff --git a/ethcore/src/evm/interpreter/mod.rs b/ethcore/src/evm/interpreter/mod.rs index 7b31ec28d..b10bf3246 100644 --- a/ethcore/src/evm/interpreter/mod.rs +++ b/ethcore/src/evm/interpreter/mod.rs @@ -107,7 +107,7 @@ impl evm::Evm for Interpreter { let code = ¶ms.code.as_ref().expect("exec always called with code; qed"); let valid_jump_destinations = self.cache.jump_destinations(¶ms.code_hash, code); - let mut gasometer = Gasometer::::new(try!(Cost::from_u256(params.gas))); + let mut gasometer = Gasometer::::new(Cost::from_u256(params.gas)?); let mut stack = VecStack::with_capacity(ext.schedule().stack_limit, U256::zero()); let mut reader = CodeReader::new(code); let infos = &*instructions::INSTRUCTIONS; @@ -117,14 +117,14 @@ impl evm::Evm for Interpreter { reader.position += 1; let info = &infos[instruction as usize]; - try!(self.verify_instruction(ext, instruction, info, &stack)); + self.verify_instruction(ext, instruction, info, &stack)?; // Calculate gas cost - let requirements = try!(gasometer.requirements(ext, instruction, info, &stack, self.mem.size())); + let requirements = gasometer.requirements(ext, instruction, info, &stack, self.mem.size())?; // TODO: make compile-time removable if too much of a performance hit. let trace_executed = ext.trace_prepare_execute(reader.position - 1, instruction, &requirements.gas_cost.as_u256()); - try!(gasometer.verify_gas(&requirements.gas_cost)); + gasometer.verify_gas(&requirements.gas_cost)?; self.mem.expand(requirements.memory_required_size); gasometer.current_mem_gas = requirements.memory_total_gas; gasometer.current_gas = gasometer.current_gas - requirements.gas_cost; @@ -137,9 +137,9 @@ impl evm::Evm for Interpreter { }; // Execute instruction - let result = try!(self.exec_instruction( + let result = self.exec_instruction( gasometer.current_gas, ¶ms, ext, instruction, &mut reader, &mut stack, requirements.provide_gas - )); + )?; evm_debug!({ informant.after_instruction(instruction) }); @@ -154,7 +154,7 @@ impl evm::Evm for Interpreter { // Advance match result { InstructionResult::JumpToPosition(position) => { - let pos = try!(self.verify_jump(position, &valid_jump_destinations)); + let pos = self.verify_jump(position, &valid_jump_destinations)?; reader.position = pos; }, InstructionResult::StopExecutionNeedsReturn(gas, off, size) => { @@ -513,7 +513,7 @@ impl Interpreter { stack.push(ext.env_info().gas_limit.clone()); }, _ => { - try!(self.exec_stack_instruction(instruction, stack)); + self.exec_stack_instruction(instruction, stack)?; } }; Ok(InstructionResult::Ok) diff --git a/ethcore/src/executive.rs b/ethcore/src/executive.rs index a6c66b067..57c63d7db 100644 --- a/ethcore/src/executive.rs +++ b/ethcore/src/executive.rs @@ -122,10 +122,10 @@ impl<'a> Executive<'a> { mut tracer: T, mut vm_tracer: V ) -> Result where T: Tracer, V: VMTracer { - let sender = try!(t.sender().map_err(|e| { + let sender = t.sender().map_err(|e| { let message = format!("Transaction malformed: {:?}", e); ExecutionError::TransactionMalformed(message) - })); + })?; let nonce = self.state.nonce(&sender); let schedule = self.engine.schedule(self.info); @@ -206,7 +206,7 @@ impl<'a> Executive<'a> { }; // finalize here! - Ok(try!(self.finalize(t, substate, gas_left, output, tracer.traces(), vm_tracer.drain()))) + Ok(self.finalize(t, substate, gas_left, output, tracer.traces(), vm_tracer.drain())?) } fn exec_vm( diff --git a/ethcore/src/header.rs b/ethcore/src/header.rs index 666ed3ec2..adc51717d 100644 --- a/ethcore/src/header.rs +++ b/ethcore/src/header.rs @@ -265,26 +265,26 @@ impl Decodable for Header { let r = decoder.as_rlp(); let mut blockheader = Header { - parent_hash: try!(r.val_at(0)), - uncles_hash: try!(r.val_at(1)), - author: try!(r.val_at(2)), - state_root: try!(r.val_at(3)), - transactions_root: try!(r.val_at(4)), - receipts_root: try!(r.val_at(5)), - log_bloom: try!(r.val_at(6)), - difficulty: try!(r.val_at(7)), - number: try!(r.val_at(8)), - gas_limit: try!(r.val_at(9)), - gas_used: try!(r.val_at(10)), - timestamp: try!(r.val_at(11)), - extra_data: try!(r.val_at(12)), + parent_hash: r.val_at(0)?, + uncles_hash: r.val_at(1)?, + author: r.val_at(2)?, + state_root: r.val_at(3)?, + transactions_root: r.val_at(4)?, + receipts_root: r.val_at(5)?, + log_bloom: r.val_at(6)?, + difficulty: r.val_at(7)?, + number: r.val_at(8)?, + gas_limit: r.val_at(9)?, + gas_used: r.val_at(10)?, + timestamp: r.val_at(11)?, + extra_data: r.val_at(12)?, seal: vec![], hash: RefCell::new(Some(r.as_raw().sha3())), bare_hash: RefCell::new(None), }; for i in 13..r.item_count() { - blockheader.seal.push(try!(r.at(i)).as_raw().to_vec()) + blockheader.seal.push(r.at(i)?.as_raw().to_vec()) } Ok(blockheader) diff --git a/ethcore/src/migrations/state/v7.rs b/ethcore/src/migrations/state/v7.rs index 69178188b..d2b11d359 100644 --- a/ethcore/src/migrations/state/v7.rs +++ b/ethcore/src/migrations/state/v7.rs @@ -109,7 +109,7 @@ impl OverlayRecentV7 { // walk all journal entries in the database backwards. // find migrations for any possible inserted keys. fn walk_journal(&mut self, source: Arc) -> Result<(), Error> { - if let Some(val) = try!(source.get(None, V7_LATEST_ERA_KEY).map_err(Error::Custom)) { + if let Some(val) = source.get(None, V7_LATEST_ERA_KEY).map_err(Error::Custom)? { let mut era = decode::(&val); loop { let mut index: usize = 0; @@ -120,7 +120,7 @@ impl OverlayRecentV7 { r.out() }; - if let Some(journal_raw) = try!(source.get(None, &entry_key).map_err(Error::Custom)) { + if let Some(journal_raw) = source.get(None, &entry_key).map_err(Error::Custom)? { let rlp = Rlp::new(&journal_raw); // migrate all inserted keys. @@ -153,8 +153,8 @@ impl OverlayRecentV7 { // replace all possible inserted/deleted keys with their migrated counterparts // and commit the altered entries. fn migrate_journal(&self, source: Arc, mut batch: Batch, dest: &mut Database) -> Result<(), Error> { - if let Some(val) = try!(source.get(None, V7_LATEST_ERA_KEY).map_err(Error::Custom)) { - try!(batch.insert(V7_LATEST_ERA_KEY.into(), val.clone().to_vec(), dest)); + if let Some(val) = source.get(None, V7_LATEST_ERA_KEY).map_err(Error::Custom)? { + batch.insert(V7_LATEST_ERA_KEY.into(), val.clone().to_vec(), dest)?; let mut era = decode::(&val); loop { @@ -166,7 +166,7 @@ impl OverlayRecentV7 { r.out() }; - if let Some(journal_raw) = try!(source.get(None, &entry_key).map_err(Error::Custom)) { + if let Some(journal_raw) = source.get(None, &entry_key).map_err(Error::Custom)? { let rlp = Rlp::new(&journal_raw); let id: H256 = rlp.val_at(0); let mut inserted_keys: Vec<(H256, Bytes)> = Vec::new(); @@ -202,7 +202,7 @@ impl OverlayRecentV7 { stream.append(&deleted_keys); // and insert it into the new database. - try!(batch.insert(entry_key, stream.out(), dest)); + batch.insert(entry_key, stream.out(), dest)?; index += 1; } else { @@ -233,7 +233,7 @@ impl Migration for OverlayRecentV7 { let mut batch = Batch::new(config, col); // check version metadata. - match try!(source.get(None, V7_VERSION_KEY).map_err(Error::Custom)) { + match source.get(None, V7_VERSION_KEY).map_err(Error::Custom)? { Some(ref version) if decode::(&*version) == DB_VERSION => {} _ => return Err(Error::MigrationImpossible), // missing or wrong version } @@ -255,10 +255,10 @@ impl Migration for OverlayRecentV7 { } } - try!(batch.insert(key, value.into_vec(), dest)); + batch.insert(key, value.into_vec(), dest)?; } - try!(self.walk_journal(source.clone())); + self.walk_journal(source.clone())?; self.migrate_journal(source, batch, dest) } } diff --git a/ethcore/src/migrations/v10.rs b/ethcore/src/migrations/v10.rs index 3726d2e97..d0e6aa9fd 100644 --- a/ethcore/src/migrations/v10.rs +++ b/ethcore/src/migrations/v10.rs @@ -32,7 +32,7 @@ use util::{Database, DBTransaction}; /// Can be called on upgraded database with no issues (will do nothing). pub fn generate_bloom(source: Arc, dest: &mut Database) -> Result<(), Error> { trace!(target: "migration", "Account bloom upgrade started"); - let best_block_hash = match try!(source.get(COL_EXTRA, b"best")) { + let best_block_hash = match source.get(COL_EXTRA, b"best")? { // no migration needed None => { trace!(target: "migration", "No best block hash, skipping"); @@ -40,7 +40,7 @@ pub fn generate_bloom(source: Arc, dest: &mut Database) -> Result<(), }, Some(hash) => hash, }; - let best_block_header = match try!(source.get(COL_HEADERS, &best_block_hash)) { + let best_block_header = match source.get(COL_HEADERS, &best_block_hash)? { // no best block, nothing to do None => { trace!(target: "migration", "No best block header, skipping"); @@ -58,9 +58,9 @@ pub fn generate_bloom(source: Arc, dest: &mut Database) -> Result<(), source.clone(), journaldb::Algorithm::OverlayRecent, COL_STATE); - let account_trie = try!(TrieDB::new(state_db.as_hashdb(), &state_root).map_err(|e| Error::Custom(format!("Cannot open trie: {:?}", e)))); - for item in try!(account_trie.iter().map_err(|_| Error::MigrationImpossible)) { - let (ref account_key, _) = try!(item.map_err(|_| Error::MigrationImpossible)); + let account_trie = TrieDB::new(state_db.as_hashdb(), &state_root).map_err(|e| Error::Custom(format!("Cannot open trie: {:?}", e)))?; + for item in account_trie.iter().map_err(|_| Error::MigrationImpossible)? { + let (ref account_key, _) = item.map_err(|_| Error::MigrationImpossible)?; let account_key_hash = H256::from_slice(account_key); bloom.set(&*account_key_hash); } @@ -71,8 +71,8 @@ pub fn generate_bloom(source: Arc, dest: &mut Database) -> Result<(), trace!(target: "migration", "Generated {} bloom updates", bloom_journal.entries.len()); let mut batch = DBTransaction::new(dest); - try!(StateDB::commit_bloom(&mut batch, bloom_journal).map_err(|_| Error::Custom("Failed to commit bloom".to_owned()))); - try!(dest.write(batch)); + StateDB::commit_bloom(&mut batch, bloom_journal).map_err(|_| Error::Custom("Failed to commit bloom".to_owned()))?; + dest.write(batch)?; trace!(target: "migration", "Finished bloom update"); @@ -104,12 +104,12 @@ impl Migration for ToV10 { let mut batch = Batch::new(config, col); for (key, value) in source.iter(col) { self.progress.tick(); - try!(batch.insert(key.to_vec(), value.to_vec(), dest)); + batch.insert(key.to_vec(), value.to_vec(), dest)?; } - try!(batch.commit(dest)); + batch.commit(dest)?; if col == COL_STATE { - try!(generate_bloom(source, dest)); + generate_bloom(source, dest)?; } Ok(()) diff --git a/ethcore/src/migrations/v9.rs b/ethcore/src/migrations/v9.rs index b99de0f51..909fa95f6 100644 --- a/ethcore/src/migrations/v9.rs +++ b/ethcore/src/migrations/v9.rs @@ -63,17 +63,17 @@ impl Migration for ToV9 { self.progress.tick(); match self.extract { Extract::Header => { - try!(batch.insert(key.to_vec(), Rlp::new(&value).at(0).as_raw().to_vec(), dest)) + batch.insert(key.to_vec(), Rlp::new(&value).at(0).as_raw().to_vec(), dest)? }, Extract::Body => { let mut body = RlpStream::new_list(2); let block_rlp = Rlp::new(&value); body.append_raw(block_rlp.at(1).as_raw(), 1); body.append_raw(block_rlp.at(2).as_raw(), 1); - try!(batch.insert(key.to_vec(), body.out(), dest)) + batch.insert(key.to_vec(), body.out(), dest)? }, Extract::All => { - try!(batch.insert(key.to_vec(), value.to_vec(), dest)) + batch.insert(key.to_vec(), value.to_vec(), dest)? } } } diff --git a/ethcore/src/miner/miner.rs b/ethcore/src/miner/miner.rs index c7bff4784..198170735 100644 --- a/ethcore/src/miner/miner.rs +++ b/ethcore/src/miner/miner.rs @@ -698,10 +698,10 @@ impl MinerService for Miner { let mut state = block.state().clone(); let original_state = if analytics.state_diffing { Some(state.clone()) } else { None }; - let sender = try!(t.sender().map_err(|e| { + let sender = t.sender().map_err(|e| { let message = format!("Transaction malformed: {:?}", e); ExecutionError::TransactionMalformed(message) - })); + })?; let balance = state.balance(&sender); let needed_balance = t.value + t.gas * t.gas_price; if balance < needed_balance { @@ -709,7 +709,7 @@ impl MinerService for Miner { state.add_balance(&sender, &(needed_balance - balance), CleanupMode::NoEmpty); } let options = TransactOptions { tracing: analytics.transaction_tracing, vm_tracing: analytics.vm_tracing, check_nonce: false }; - let mut ret = try!(Executive::new(&mut state, &env_info, &*self.engine, chain.vm_factory()).transact(t, options)); + let mut ret = Executive::new(&mut state, &env_info, &*self.engine, chain.vm_factory()).transact(t, options)?; // TODO gav move this into Executive. ret.state_diff = original_state.map(|original| state.diff_from(original)); @@ -765,7 +765,7 @@ impl MinerService for Miner { fn set_engine_signer(&self, address: Address, password: String) -> Result<(), AccountError> { if self.seals_internally { if let Some(ref ap) = self.accounts { - try!(ap.sign(address.clone(), Some(password.clone()), Default::default())); + ap.sign(address.clone(), Some(password.clone()), Default::default())?; } let mut sealing_work = self.sealing_work.lock(); sealing_work.enabled = self.engine.is_sealer(&address).unwrap_or(false); @@ -1104,7 +1104,7 @@ impl MinerService for Miner { result.and_then(|sealed| { let n = sealed.header().number(); let h = sealed.header().hash(); - try!(chain.import_sealed_block(sealed)); + chain.import_sealed_block(sealed)?; info!(target: "miner", "Submitted block imported OK. #{}: {}", Colour::White.bold().paint(format!("{}", n)), Colour::White.bold().paint(h.hex())); Ok(()) }) diff --git a/ethcore/src/miner/price_info.rs b/ethcore/src/miner/price_info.rs index e1cf82f99..897440ebe 100644 --- a/ethcore/src/miner/price_info.rs +++ b/ethcore/src/miner/price_info.rs @@ -65,7 +65,7 @@ impl Handler for SetPriceH impl PriceInfo { pub fn get(set_price: F) -> Result<(), ()> { // TODO: Handle each error type properly - let client = try!(Client::new().map_err(|_| ())); + let client = Client::new().map_err(|_| ())?; thread::spawn(move || { let (tx, rx) = mpsc::channel(); let url = FromStr::from_str("http://api.etherscan.io/api?module=stats&action=ethprice") diff --git a/ethcore/src/miner/transaction_queue.rs b/ethcore/src/miner/transaction_queue.rs index 9f5b6399a..a51c70bc0 100644 --- a/ethcore/src/miner/transaction_queue.rs +++ b/ethcore/src/miner/transaction_queue.rs @@ -264,7 +264,7 @@ struct VerifiedTransaction { impl VerifiedTransaction { fn new(transaction: SignedTransaction, origin: TransactionOrigin, min_block: Option) -> Result { - try!(transaction.sender()); + transaction.sender()?; Ok(VerifiedTransaction { transaction: transaction, origin: origin, @@ -732,9 +732,9 @@ impl TransactionQueue { } // Verify signature - try!(tx.check_low_s()); + tx.check_low_s()?; - let vtx = try!(VerifiedTransaction::new(tx, origin, min_block)); + let vtx = VerifiedTransaction::new(tx, origin, min_block)?; let client_account = fetch_account(&vtx.sender()); let cost = vtx.transaction.value + vtx.transaction.gas_price * vtx.transaction.gas; @@ -1138,13 +1138,13 @@ impl TransactionQueue { if nonce > next_nonce { // We have a gap - put to future. // Insert transaction (or replace old one with lower gas price) - try!(check_too_cheap( + check_too_cheap( Self::replace_transaction(tx, state_nonce, min_gas_price, &mut self.future, &mut self.by_hash, &mut self.local_transactions) - )); + )?; // Enforce limit in Future let removed = self.future.enforce_limit(&mut self.by_hash, &mut self.local_transactions); // Return an error if this transaction was not imported because of limit. - try!(check_if_removed(&address, &nonce, removed)); + check_if_removed(&address, &nonce, removed)?; debug!(target: "txqueue", "Importing transaction to future: {:?}", hash); debug!(target: "txqueue", "status: {:?}", self.status()); @@ -1156,9 +1156,9 @@ impl TransactionQueue { self.move_matching_future_to_current(address, nonce + U256::one(), state_nonce); // Replace transaction if any - try!(check_too_cheap( + check_too_cheap( Self::replace_transaction(tx, state_nonce, min_gas_price, &mut self.current, &mut self.by_hash, &mut self.local_transactions) - )); + )?; // Keep track of highest nonce stored in current let new_max = self.last_nonces.get(&address).map_or(nonce, |n| cmp::max(nonce, *n)); self.last_nonces.insert(address, new_max); @@ -1168,7 +1168,7 @@ impl TransactionQueue { // If some transaction were removed because of limit we need to update last_nonces also. self.update_last_nonces(&removed); // Trigger error if the transaction we are importing was removed. - try!(check_if_removed(&address, &nonce, removed)); + check_if_removed(&address, &nonce, removed)?; debug!(target: "txqueue", "Imported transaction to current: {:?}", hash); debug!(target: "txqueue", "status: {:?}", self.status()); diff --git a/ethcore/src/pod_state.rs b/ethcore/src/pod_state.rs index 18045c510..fa6cbc082 100644 --- a/ethcore/src/pod_state.rs +++ b/ethcore/src/pod_state.rs @@ -64,7 +64,7 @@ impl From for PodState { impl fmt::Display for PodState { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { for (add, acc) in &self.0 { - try!(writeln!(f, "{} => {}", add, acc)); + writeln!(f, "{} => {}", add, acc)?; } Ok(()) } diff --git a/ethcore/src/service.rs b/ethcore/src/service.rs index 732d12a5b..b0f1df420 100644 --- a/ethcore/src/service.rs +++ b/ethcore/src/service.rs @@ -77,7 +77,7 @@ impl ClientService { ) -> Result { let panic_handler = PanicHandler::new_in_arc(); - let io_service = try!(IoService::::start()); + let io_service = IoService::::start()?; panic_handler.forward_from(&io_service); info!("Configured for {} using {} engine", Colour::White.bold().paint(spec.name.clone()), Colour::Yellow.bold().paint(spec.engine.name())); @@ -94,7 +94,7 @@ impl ClientService { db_config.wal = config.db_wal; let pruning = config.pruning; - let client = try!(Client::new(config, &spec, client_path, miner, io_service.channel(), &db_config)); + let client = Client::new(config, &spec, client_path, miner, io_service.channel(), &db_config)?; let snapshot_params = SnapServiceParams { engine: spec.engine.clone(), @@ -105,14 +105,14 @@ impl ClientService { snapshot_root: snapshot_path.into(), db_restore: client.clone(), }; - let snapshot = Arc::new(try!(SnapshotService::new(snapshot_params))); + let snapshot = Arc::new(SnapshotService::new(snapshot_params)?); panic_handler.forward_from(&*client); let client_io = Arc::new(ClientIoHandler { client: client.clone(), snapshot: snapshot.clone(), }); - try!(io_service.register_handler(client_io)); + io_service.register_handler(client_io)?; spec.engine.register_message_channel(io_service.channel()); diff --git a/ethcore/src/snapshot/account.rs b/ethcore/src/snapshot/account.rs index 9d5385d92..0dfb72955 100644 --- a/ethcore/src/snapshot/account.rs +++ b/ethcore/src/snapshot/account.rs @@ -100,12 +100,12 @@ impl Account { return Ok(::rlp::NULL_RLP.to_vec()); } - let db = try!(TrieDB::new(acct_db, &self.storage_root)); + let db = TrieDB::new(acct_db, &self.storage_root)?; let mut pairs = Vec::new(); - for item in try!(db.iter()) { - let (k, v) = try!(item); + for item in db.iter()? { + let (k, v) = item?; pairs.push((k, v)); } @@ -158,24 +158,24 @@ impl Account { return Ok((ACC_EMPTY, None)); } - let nonce = try!(rlp.val_at(0)); - let balance = try!(rlp.val_at(1)); + let nonce = rlp.val_at(0)?; + let balance = rlp.val_at(1)?; let code_state: CodeState = { - let raw: u8 = try!(rlp.val_at(2)); - try!(CodeState::from(raw)) + let raw: u8 = rlp.val_at(2)?; + CodeState::from(raw)? }; // load the code if it exists. let (code_hash, new_code) = match code_state { CodeState::Empty => (SHA3_EMPTY, None), CodeState::Inline => { - let code: Bytes = try!(rlp.val_at(3)); + let code: Bytes = rlp.val_at(3)?; let code_hash = acct_db.insert(&code); (code_hash, Some(code)) } CodeState::Hash => { - let code_hash = try!(rlp.val_at(3)); + let code_hash = rlp.val_at(3)?; (code_hash, None) } @@ -185,12 +185,12 @@ impl Account { { let mut storage_trie = TrieDBMut::new(acct_db, &mut storage_root); - let pairs = try!(rlp.at(4)); + let pairs = rlp.at(4)?; for pair_rlp in pairs.iter() { - let k: Bytes = try!(pair_rlp.val_at(0)); - let v: Bytes = try!(pair_rlp.val_at(1)); + let k: Bytes = pair_rlp.val_at(0)?; + let v: Bytes = pair_rlp.val_at(1)?; - try!(storage_trie.insert(&k, &v)); + storage_trie.insert(&k, &v)?; } } diff --git a/ethcore/src/snapshot/block.rs b/ethcore/src/snapshot/block.rs index 94b7a4289..5b3846b6c 100644 --- a/ethcore/src/snapshot/block.rs +++ b/ethcore/src/snapshot/block.rs @@ -89,21 +89,21 @@ impl AbridgedBlock { let mut header: Header = Default::default(); header.set_parent_hash(parent_hash); - header.set_author(try!(rlp.val_at(0))); - header.set_state_root(try!(rlp.val_at(1))); - header.set_log_bloom(try!(rlp.val_at(2))); - header.set_difficulty(try!(rlp.val_at(3))); + header.set_author(rlp.val_at(0)?); + header.set_state_root(rlp.val_at(1)?); + header.set_log_bloom(rlp.val_at(2)?); + header.set_difficulty(rlp.val_at(3)?); header.set_number(number); - header.set_gas_limit(try!(rlp.val_at(4))); - header.set_gas_used(try!(rlp.val_at(5))); - header.set_timestamp(try!(rlp.val_at(6))); - header.set_extra_data(try!(rlp.val_at(7))); + header.set_gas_limit(rlp.val_at(4)?); + header.set_gas_used(rlp.val_at(5)?); + header.set_timestamp(rlp.val_at(6)?); + header.set_extra_data(rlp.val_at(7)?); - let transactions = try!(rlp.val_at(8)); - let uncles: Vec
= try!(rlp.val_at(9)); + let transactions = rlp.val_at(8)?; + let uncles: Vec
= rlp.val_at(9)?; header.set_transactions_root(ordered_trie_root( - try!(rlp.at(8)).iter().map(|r| r.as_raw().to_owned()) + rlp.at(8)?.iter().map(|r| r.as_raw().to_owned()) )); header.set_receipts_root(receipts_root); @@ -113,7 +113,7 @@ impl AbridgedBlock { let mut seal_fields = Vec::new(); for i in (HEADER_FIELDS + BLOCK_FIELDS)..rlp.item_count() { - let seal_rlp = try!(rlp.at(i)); + let seal_rlp = rlp.at(i)?; seal_fields.push(seal_rlp.as_raw().to_owned()); } diff --git a/ethcore/src/snapshot/io.rs b/ethcore/src/snapshot/io.rs index 2d581d571..9ef2ad5cb 100644 --- a/ethcore/src/snapshot/io.rs +++ b/ethcore/src/snapshot/io.rs @@ -60,9 +60,9 @@ impl rlp::Decodable for ChunkInfo { fn decode(decoder: &D) -> Result { let d = decoder.as_rlp(); - let hash = try!(d.val_at(0)); - let len = try!(d.val_at(1)); - let off = try!(d.val_at(2)); + let hash = d.val_at(0)?; + let len = d.val_at(1)?; + let off = d.val_at(2)?; Ok(ChunkInfo(hash, len, off)) } } @@ -88,7 +88,7 @@ impl PackedWriter { /// Create a new "PackedWriter", to write into the file at the given path. pub fn new(path: &Path) -> io::Result { Ok(PackedWriter { - file: try!(File::create(path)), + file: File::create(path)?, state_hashes: Vec::new(), block_hashes: Vec::new(), cur_len: 0, @@ -98,7 +98,7 @@ impl PackedWriter { impl SnapshotWriter for PackedWriter { fn write_state_chunk(&mut self, hash: H256, chunk: &[u8]) -> io::Result<()> { - try!(self.file.write_all(chunk)); + self.file.write_all(chunk)?; let len = chunk.len() as u64; self.state_hashes.push(ChunkInfo(hash, len, self.cur_len)); @@ -108,7 +108,7 @@ impl SnapshotWriter for PackedWriter { } fn write_block_chunk(&mut self, hash: H256, chunk: &[u8]) -> io::Result<()> { - try!(self.file.write_all(chunk)); + self.file.write_all(chunk)?; let len = chunk.len() as u64; self.block_hashes.push(ChunkInfo(hash, len, self.cur_len)); @@ -130,7 +130,7 @@ impl SnapshotWriter for PackedWriter { let manifest_rlp = stream.out(); - try!(self.file.write_all(&manifest_rlp)); + self.file.write_all(&manifest_rlp)?; let off = self.cur_len; trace!(target: "snapshot_io", "writing manifest of len {} to offset {}", manifest_rlp.len(), off); @@ -146,7 +146,7 @@ impl SnapshotWriter for PackedWriter { (off >> 56) as u8, ]; - try!(self.file.write_all(&off_bytes[..])); + self.file.write_all(&off_bytes[..])?; Ok(()) } @@ -161,7 +161,7 @@ impl LooseWriter { /// Create a new LooseWriter which will write into the given directory, /// creating it if it doesn't exist. pub fn new(path: PathBuf) -> io::Result { - try!(fs::create_dir_all(&path)); + fs::create_dir_all(&path)?; Ok(LooseWriter { dir: path, @@ -173,8 +173,8 @@ impl LooseWriter { let mut file_path = self.dir.clone(); file_path.push(hash.hex()); - let mut file = try!(File::create(file_path)); - try!(file.write_all(chunk)); + let mut file = File::create(file_path)?; + file.write_all(chunk)?; Ok(()) } @@ -194,8 +194,8 @@ impl SnapshotWriter for LooseWriter { let mut path = self.dir.clone(); path.push("MANIFEST"); - let mut file = try!(File::create(path)); - try!(file.write_all(&rlp[..])); + let mut file = File::create(path)?; + file.write_all(&rlp[..])?; Ok(()) } @@ -224,18 +224,18 @@ impl PackedReader { /// This will fail if any io errors are encountered or the file /// is not a valid packed snapshot. pub fn new(path: &Path) -> Result, ::error::Error> { - let mut file = try!(File::open(path)); - let file_len = try!(file.metadata()).len(); + let mut file = File::open(path)?; + let file_len = file.metadata()?.len(); if file_len < 8 { // ensure we don't seek before beginning. return Ok(None); } - try!(file.seek(SeekFrom::End(-8))); + file.seek(SeekFrom::End(-8))?; let mut off_bytes = [0u8; 8]; - try!(file.read_exact(&mut off_bytes[..])); + file.read_exact(&mut off_bytes[..])?; let manifest_off: u64 = ((off_bytes[7] as u64) << 56) + @@ -252,20 +252,20 @@ impl PackedReader { let mut manifest_buf = vec![0; manifest_len as usize]; - try!(file.seek(SeekFrom::Start(manifest_off))); - try!(file.read_exact(&mut manifest_buf)); + file.seek(SeekFrom::Start(manifest_off))?; + file.read_exact(&mut manifest_buf)?; let rlp = UntrustedRlp::new(&manifest_buf); - let state: Vec = try!(rlp.val_at(0)); - let blocks: Vec = try!(rlp.val_at(1)); + let state: Vec = rlp.val_at(0)?; + let blocks: Vec = rlp.val_at(1)?; let manifest = ManifestData { state_hashes: state.iter().map(|c| c.0).collect(), block_hashes: blocks.iter().map(|c| c.0).collect(), - state_root: try!(rlp.val_at(2)), - block_number: try!(rlp.val_at(3)), - block_hash: try!(rlp.val_at(4)), + state_root: rlp.val_at(2)?, + block_number: rlp.val_at(3)?, + block_hash: rlp.val_at(4)?, }; Ok(Some(PackedReader { @@ -288,10 +288,10 @@ impl SnapshotReader for PackedReader { let mut file = &self.file; - try!(file.seek(SeekFrom::Start(off))); + file.seek(SeekFrom::Start(off))?; let mut buf = vec![0; len as usize]; - try!(file.read_exact(&mut buf[..])); + file.read_exact(&mut buf[..])?; Ok(buf) } @@ -310,10 +310,10 @@ impl LooseReader { let mut manifest_buf = Vec::new(); dir.push("MANIFEST"); - let mut manifest_file = try!(File::open(&dir)); - try!(manifest_file.read_to_end(&mut manifest_buf)); + let mut manifest_file = File::open(&dir)?; + manifest_file.read_to_end(&mut manifest_buf)?; - let manifest = try!(ManifestData::from_rlp(&manifest_buf[..])); + let manifest = ManifestData::from_rlp(&manifest_buf[..])?; dir.pop(); @@ -334,9 +334,9 @@ impl SnapshotReader for LooseReader { path.push(hash.hex()); let mut buf = Vec::new(); - let mut file = try!(File::open(&path)); + let mut file = File::open(&path)?; - try!(file.read_to_end(&mut buf)); + file.read_to_end(&mut buf)?; Ok(buf) } diff --git a/ethcore/src/snapshot/mod.rs b/ethcore/src/snapshot/mod.rs index 1e646effc..557f5160a 100644 --- a/ethcore/src/snapshot/mod.rs +++ b/ethcore/src/snapshot/mod.rs @@ -128,22 +128,22 @@ pub fn take_snapshot( writer: W, p: &Progress ) -> Result<(), Error> { - let start_header = try!(chain.block_header(&block_at) - .ok_or(Error::InvalidStartingBlock(BlockId::Hash(block_at)))); + let start_header = chain.block_header(&block_at) + .ok_or(Error::InvalidStartingBlock(BlockId::Hash(block_at)))?; let state_root = start_header.state_root(); let number = start_header.number(); info!("Taking snapshot starting at block {}", number); let writer = Mutex::new(writer); - let (state_hashes, block_hashes) = try!(scope(|scope| { + let (state_hashes, block_hashes) = scope(|scope| { let block_guard = scope.spawn(|| chunk_blocks(chain, block_at, &writer, p)); let state_res = chunk_state(state_db, state_root, &writer, p); state_res.and_then(|state_hashes| { block_guard.join().map(|block_hashes| (state_hashes, block_hashes)) }) - })); + })?; info!("produced {} state chunks and {} block chunks.", state_hashes.len(), block_hashes.len()); @@ -155,7 +155,7 @@ pub fn take_snapshot( block_hash: block_at, }; - try!(writer.into_inner().finish(manifest_data)); + writer.into_inner().finish(manifest_data)?; p.done.store(true, Ordering::SeqCst); @@ -186,9 +186,9 @@ impl<'a> BlockChunker<'a> { for _ in 0..SNAPSHOT_BLOCKS { if self.current_hash == genesis_hash { break } - let (block, receipts) = try!(self.chain.block(&self.current_hash) + let (block, receipts) = self.chain.block(&self.current_hash) .and_then(|b| self.chain.block_receipts(&self.current_hash).map(|r| (b, r))) - .ok_or(Error::BlockNotFound(self.current_hash))); + .ok_or(Error::BlockNotFound(self.current_hash))?; let view = BlockView::new(&block); let abridged_rlp = AbridgedBlock::from_block_view(&view).into_inner(); @@ -204,7 +204,7 @@ impl<'a> BlockChunker<'a> { // cut off the chunk if too large. if new_loaded_size > PREFERRED_CHUNK_SIZE && !self.rlps.is_empty() { - try!(self.write_chunk(last)); + self.write_chunk(last)?; loaded_size = pair.len(); } else { loaded_size = new_loaded_size; @@ -217,7 +217,7 @@ impl<'a> BlockChunker<'a> { } if loaded_size != 0 { - try!(self.write_chunk(last)); + self.write_chunk(last)?; } Ok(()) @@ -230,9 +230,9 @@ impl<'a> BlockChunker<'a> { fn write_chunk(&mut self, last: H256) -> Result<(), Error> { trace!(target: "snapshot", "prepared block chunk with {} blocks", self.rlps.len()); - let (last_header, last_details) = try!(self.chain.block_header(&last) + let (last_header, last_details) = self.chain.block_header(&last) .and_then(|n| self.chain.block_details(&last).map(|d| (n, d))) - .ok_or(Error::BlockNotFound(last))); + .ok_or(Error::BlockNotFound(last))?; let parent_number = last_header.number() - 1; let parent_hash = last_header.parent_hash(); @@ -254,7 +254,7 @@ impl<'a> BlockChunker<'a> { let compressed = &self.snappy_buffer[..size]; let hash = compressed.sha3(); - try!(self.writer.lock().write_block_chunk(hash, compressed)); + self.writer.lock().write_block_chunk(hash, compressed)?; trace!(target: "snapshot", "wrote block chunk. hash: {}, size: {}, uncompressed size: {}", hash.hex(), size, raw_data.len()); self.progress.size.fetch_add(size, Ordering::SeqCst); @@ -282,7 +282,7 @@ pub fn chunk_blocks<'a>(chain: &'a BlockChain, start_hash: H256, writer: &Mutex< progress: progress, }; - try!(chunker.chunk_all()); + chunker.chunk_all()?; Ok(chunker.hashes) } @@ -310,7 +310,7 @@ impl<'a> StateChunker<'a> { }; if self.cur_size + pair.len() >= PREFERRED_CHUNK_SIZE { - try!(self.write_chunk()); + self.write_chunk()?; } self.cur_size += pair.len(); @@ -334,7 +334,7 @@ impl<'a> StateChunker<'a> { let compressed = &self.snappy_buffer[..compressed_size]; let hash = compressed.sha3(); - try!(self.writer.lock().write_state_chunk(hash, compressed)); + self.writer.lock().write_state_chunk(hash, compressed)?; trace!(target: "snapshot", "wrote state chunk. size: {}, uncompressed size: {}", compressed_size, raw_data.len()); self.progress.accounts.fetch_add(num_entries, Ordering::SeqCst); @@ -353,7 +353,7 @@ impl<'a> StateChunker<'a> { /// Returns a list of hashes of chunks created, or any error it may /// have encountered. pub fn chunk_state<'a>(db: &HashDB, root: &H256, writer: &Mutex, progress: &'a Progress) -> Result, Error> { - let account_trie = try!(TrieDB::new(db, &root)); + let account_trie = TrieDB::new(db, &root)?; let mut chunker = StateChunker { hashes: Vec::new(), @@ -367,19 +367,19 @@ pub fn chunk_state<'a>(db: &HashDB, root: &H256, writer: &Mutex { // if so, load it from the database. - let code = try!(AccountDB::from_hash(db, first_with) + let code = AccountDB::from_hash(db, first_with) .get(&code_hash) - .ok_or_else(|| Error::MissingCode(vec![first_with]))); + .ok_or_else(|| Error::MissingCode(vec![first_with]))?; // and write it again under a different mangled key AccountDBMut::from_hash(db, hash).emplace(code_hash, code); @@ -586,7 +586,7 @@ impl BlockRebuilder { Ok(BlockRebuilder { chain: chain, db: db, - rng: try!(OsRng::new()), + rng: OsRng::new()?, disconnected: Vec::new(), best_number: manifest.block_number, best_hash: manifest.block_hash, @@ -613,22 +613,22 @@ impl BlockRebuilder { } // todo: assert here that these values are consistent with chunks being in order. - let mut cur_number = try!(rlp.val_at::(0)) + 1; - let mut parent_hash = try!(rlp.val_at::(1)); - let parent_total_difficulty = try!(rlp.val_at::(2)); + let mut cur_number = rlp.val_at::(0)? + 1; + let mut parent_hash = rlp.val_at::(1)?; + let parent_total_difficulty = rlp.val_at::(2)?; for idx in 3..item_count { if !abort_flag.load(Ordering::SeqCst) { return Err(Error::RestorationAborted.into()) } - let pair = try!(rlp.at(idx)); - let abridged_rlp = try!(pair.at(0)).as_raw().to_owned(); + let pair = rlp.at(idx)?; + let abridged_rlp = pair.at(0)?.as_raw().to_owned(); let abridged_block = AbridgedBlock::from_raw(abridged_rlp); - let receipts: Vec<::receipt::Receipt> = try!(pair.val_at(1)); + let receipts: Vec<::receipt::Receipt> = pair.val_at(1)?; let receipts_root = ordered_trie_root( - try!(pair.at(1)).iter().map(|r| r.as_raw().to_owned()) + pair.at(1)?.iter().map(|r| r.as_raw().to_owned()) ); - let block = try!(abridged_block.to_block(parent_hash, cur_number, receipts_root)); + let block = abridged_block.to_block(parent_hash, cur_number, receipts_root)?; let block_bytes = block.rlp_bytes(With); let is_best = cur_number == self.best_number; @@ -642,14 +642,14 @@ impl BlockRebuilder { } } - try!(verify_old_block( + verify_old_block( &mut self.rng, &block.header, engine, &self.chain, Some(&block_bytes), is_best - )); + )?; let mut batch = self.db.transaction(); @@ -693,7 +693,7 @@ impl BlockRebuilder { let best_number = self.best_number; for num in (0..self.fed_blocks).map(|x| best_number - x) { - let hash = try!(self.chain.block_hash(num).ok_or(Error::IncompleteChain)); + let hash = self.chain.block_hash(num).ok_or(Error::IncompleteChain)?; if let Some(canon_hash) = canonical.get(&num).cloned() { if canon_hash != hash { diff --git a/ethcore/src/snapshot/service.rs b/ethcore/src/snapshot/service.rs index b433108fd..8d0d14ac7 100644 --- a/ethcore/src/snapshot/service.rs +++ b/ethcore/src/snapshot/service.rs @@ -97,11 +97,11 @@ impl Restoration { let state_chunks = manifest.state_hashes.iter().cloned().collect(); let block_chunks = manifest.block_hashes.iter().cloned().collect(); - let raw_db = Arc::new(try!(Database::open(params.db_config, &*params.db_path.to_string_lossy()) - .map_err(UtilError::SimpleString))); + let raw_db = Arc::new(Database::open(params.db_config, &*params.db_path.to_string_lossy()) + .map_err(UtilError::SimpleString)?); let chain = BlockChain::new(Default::default(), params.genesis, raw_db.clone(), params.engine); - let blocks = try!(BlockRebuilder::new(chain, raw_db.clone(), &manifest)); + let blocks = BlockRebuilder::new(chain, raw_db.clone(), &manifest)?; let root = manifest.state_root.clone(); Ok(Restoration { @@ -122,12 +122,12 @@ impl Restoration { // feeds a state chunk, aborts early if `flag` becomes false. fn feed_state(&mut self, hash: H256, chunk: &[u8], flag: &AtomicBool) -> Result<(), Error> { if self.state_chunks_left.remove(&hash) { - let len = try!(snappy::decompress_into(chunk, &mut self.snappy_buffer)); + let len = snappy::decompress_into(chunk, &mut self.snappy_buffer)?; - try!(self.state.feed(&self.snappy_buffer[..len], flag)); + self.state.feed(&self.snappy_buffer[..len], flag)?; if let Some(ref mut writer) = self.writer.as_mut() { - try!(writer.write_state_chunk(hash, chunk)); + writer.write_state_chunk(hash, chunk)?; } } @@ -137,11 +137,11 @@ impl Restoration { // feeds a block chunk fn feed_blocks(&mut self, hash: H256, chunk: &[u8], engine: &Engine, flag: &AtomicBool) -> Result<(), Error> { if self.block_chunks_left.remove(&hash) { - let len = try!(snappy::decompress_into(chunk, &mut self.snappy_buffer)); + let len = snappy::decompress_into(chunk, &mut self.snappy_buffer)?; - try!(self.blocks.feed(&self.snappy_buffer[..len], engine, flag)); + self.blocks.feed(&self.snappy_buffer[..len], engine, flag)?; if let Some(ref mut writer) = self.writer.as_mut() { - try!(writer.write_block_chunk(hash, chunk)); + writer.write_block_chunk(hash, chunk)?; } } @@ -167,13 +167,13 @@ impl Restoration { } // check for missing code. - try!(self.state.check_missing()); + self.state.check_missing()?; // connect out-of-order chunks and verify chain integrity. - try!(self.blocks.finalize(self.canonical_hashes)); + self.blocks.finalize(self.canonical_hashes)?; if let Some(writer) = self.writer { - try!(writer.finish(self.manifest)); + writer.finish(self.manifest)?; } self.guard.disarm(); @@ -315,7 +315,7 @@ impl Service { fn replace_client_db(&self) -> Result<(), Error> { let our_db = self.restoration_db(); - try!(self.db_restore.restore_db(&*our_db.to_string_lossy())); + self.db_restore.restore_db(&*our_db.to_string_lossy())?; Ok(()) } @@ -351,7 +351,7 @@ impl Service { let _ = fs::remove_dir_all(&temp_dir); - let writer = try!(LooseWriter::new(temp_dir.clone())); + let writer = LooseWriter::new(temp_dir.clone())?; let guard = Guard::new(temp_dir.clone()); let res = client.take_snapshot(writer, BlockId::Number(num), &self.progress); @@ -378,12 +378,12 @@ impl Service { *reader = None; if snapshot_dir.exists() { - try!(fs::remove_dir_all(&snapshot_dir)); + fs::remove_dir_all(&snapshot_dir)?; } - try!(fs::rename(temp_dir, &snapshot_dir)); + fs::rename(temp_dir, &snapshot_dir)?; - *reader = Some(try!(LooseReader::new(snapshot_dir))); + *reader = Some(LooseReader::new(snapshot_dir)?); guard.disarm(); Ok(()) @@ -410,11 +410,11 @@ impl Service { } } - try!(fs::create_dir_all(&rest_dir)); + fs::create_dir_all(&rest_dir)?; // make new restoration. let writer = match recover { - true => Some(try!(LooseWriter::new(self.temp_recovery_dir()))), + true => Some(LooseWriter::new(self.temp_recovery_dir())?), false => None }; @@ -432,7 +432,7 @@ impl Service { let state_chunks = params.manifest.state_hashes.len(); let block_chunks = params.manifest.block_hashes.len(); - *res = Some(try!(Restoration::new(params))); + *res = Some(Restoration::new(params)?); *self.status.lock() = RestorationStatus::Ongoing { state_chunks: state_chunks as u32, @@ -454,8 +454,8 @@ impl Service { let recover = rest.as_ref().map_or(false, |rest| rest.writer.is_some()); // destroy the restoration before replacing databases and snapshot. - try!(rest.take().map(Restoration::finalize).unwrap_or(Ok(()))); - try!(self.replace_client_db()); + rest.take().map(Restoration::finalize).unwrap_or(Ok(()))?; + self.replace_client_db()?; if recover { let mut reader = self.reader.write(); @@ -465,13 +465,13 @@ impl Service { if snapshot_dir.exists() { trace!(target: "snapshot", "removing old snapshot dir at {}", snapshot_dir.to_string_lossy()); - try!(fs::remove_dir_all(&snapshot_dir)); + fs::remove_dir_all(&snapshot_dir)?; } trace!(target: "snapshot", "copying restored snapshot files over"); - try!(fs::rename(self.temp_recovery_dir(), &snapshot_dir)); + fs::rename(self.temp_recovery_dir(), &snapshot_dir)?; - *reader = Some(try!(LooseReader::new(snapshot_dir))); + *reader = Some(LooseReader::new(snapshot_dir)?); } let _ = fs::remove_dir_all(self.restoration_dir()); @@ -510,7 +510,7 @@ impl Service { match is_done { true => { - try!(db.flush().map_err(::util::UtilError::SimpleString)); + db.flush().map_err(::util::UtilError::SimpleString)?; drop(db); return self.finalize_restoration(&mut *restoration); }, diff --git a/ethcore/src/spec/spec.rs b/ethcore/src/spec/spec.rs index 9749ff770..3fb04fc36 100644 --- a/ethcore/src/spec/spec.rs +++ b/ethcore/src/spec/spec.rs @@ -259,7 +259,7 @@ impl Spec { { let mut t = factories.trie.create(db.as_hashdb_mut(), &mut root); for (address, account) in self.genesis_state.get().iter() { - try!(t.insert(&**address, &account.rlp())); + t.insert(&**address, &account.rlp())?; } } diff --git a/ethcore/src/state/account.rs b/ethcore/src/state/account.rs index d778412c4..49cebd550 100644 --- a/ethcore/src/state/account.rs +++ b/ethcore/src/state/account.rs @@ -450,8 +450,8 @@ impl Account { let mut recorder = TrieRecorder::with_depth(from_level); - let trie = try!(TrieDB::new(db, &self.storage_root)); - let _ = try!(trie.get_recorded(&storage_key, &mut recorder)); + let trie = TrieDB::new(db, &self.storage_root)?; + let _ = trie.get_recorded(&storage_key, &mut recorder)?; Ok(recorder.drain().into_iter().map(|r| r.data).collect()) } diff --git a/ethcore/src/state/mod.rs b/ethcore/src/state/mod.rs index 76bb71645..c9730c1c3 100644 --- a/ethcore/src/state/mod.rs +++ b/ethcore/src/state/mod.rs @@ -515,11 +515,11 @@ impl State { let options = TransactOptions { tracing: tracing, vm_tracing: false, check_nonce: true }; let vm_factory = self.factories.vm.clone(); - let e = try!(Executive::new(self, env_info, engine, &vm_factory).transact(t, options)); + let e = Executive::new(self, env_info, engine, &vm_factory).transact(t, options)?; // TODO uncomment once to_pod() works correctly. // trace!("Applied transaction. Diff:\n{}\n", state_diff::diff_pod(&old, &self.to_pod())); - try!(self.commit()); + self.commit()?; let receipt = Receipt::new(self.root().clone(), e.cumulative_gas_used, e.logs); trace!(target: "state", "Transaction receipt: {:?}", receipt); Ok(ApplyOutcome{receipt: receipt, trace: e.trace}) @@ -551,15 +551,15 @@ impl State { } { - let mut trie = try!(factories.trie.from_existing(db.as_hashdb_mut(), root)); + let mut trie = factories.trie.from_existing(db.as_hashdb_mut(), root)?; for (address, ref mut a) in accounts.iter_mut().filter(|&(_, ref a)| a.is_dirty()) { a.state = AccountState::Committed; match a.account { Some(ref mut account) => { - try!(trie.insert(address, &account.rlp())); + trie.insert(address, &account.rlp())?; }, None => { - try!(trie.remove(address)); + trie.remove(address)?; }, } } @@ -771,8 +771,8 @@ impl State { /// `account_key` == sha3(address) pub fn prove_account(&self, account_key: H256, from_level: u32) -> Result, Box> { let mut recorder = TrieRecorder::with_depth(from_level); - let trie = try!(TrieDB::new(self.db.as_hashdb(), &self.root)); - let _ = try!(trie.get_recorded(&account_key, &mut recorder)); + let trie = TrieDB::new(self.db.as_hashdb(), &self.root)?; + let _ = trie.get_recorded(&account_key, &mut recorder)?; Ok(recorder.drain().into_iter().map(|r| r.data).collect()) } @@ -785,8 +785,8 @@ impl State { pub fn prove_storage(&self, account_key: H256, storage_key: H256, from_level: u32) -> Result, Box> { // TODO: probably could look into cache somehow but it's keyed by // address, not sha3(address). - let trie = try!(TrieDB::new(self.db.as_hashdb(), &self.root)); - let acc = match try!(trie.get(&account_key)) { + let trie = TrieDB::new(self.db.as_hashdb(), &self.root)?; + let acc = match trie.get(&account_key)? { Some(rlp) => Account::from_rlp(&rlp), None => return Ok(Vec::new()), }; @@ -798,8 +798,8 @@ impl State { /// Get code by address hash. /// Only works when backed by a secure trie. pub fn code_by_address_hash(&self, account_key: H256) -> Result, Box> { - let trie = try!(TrieDB::new(self.db.as_hashdb(), &self.root)); - let mut acc = match try!(trie.get(&account_key)) { + let trie = TrieDB::new(self.db.as_hashdb(), &self.root)?; + let mut acc = match trie.get(&account_key)? { Some(rlp) => Account::from_rlp(&rlp), None => return Ok(None), }; diff --git a/ethcore/src/state_db.rs b/ethcore/src/state_db.rs index d38449f7a..967c23513 100644 --- a/ethcore/src/state_db.rs +++ b/ethcore/src/state_db.rs @@ -195,9 +195,9 @@ impl StateDB { pub fn journal_under(&mut self, batch: &mut DBTransaction, now: u64, id: &H256) -> Result { { let mut bloom_lock = self.account_bloom.lock(); - try!(Self::commit_bloom(batch, bloom_lock.drain_journal())); + Self::commit_bloom(batch, bloom_lock.drain_journal())?; } - let records = try!(self.db.journal_under(batch, now, id)); + let records = self.db.journal_under(batch, now, id)?; self.commit_hash = Some(id.clone()); self.commit_number = Some(now); Ok(records) diff --git a/ethcore/src/trace/bloom.rs b/ethcore/src/trace/bloom.rs index 9196453fd..4e2bd4eca 100644 --- a/ethcore/src/trace/bloom.rs +++ b/ethcore/src/trace/bloom.rs @@ -73,7 +73,7 @@ impl Encodable for BlockTracesBloom { impl Decodable for BlockTracesBloomGroup { fn decode(decoder: &D) -> Result where D: Decoder { - let blooms = try!(Decodable::decode(decoder)); + let blooms = Decodable::decode(decoder)?; let group = BlockTracesBloomGroup { blooms: blooms }; diff --git a/ethcore/src/types/account_diff.rs b/ethcore/src/types/account_diff.rs index 96180aefd..53ab6775c 100644 --- a/ethcore/src/types/account_diff.rs +++ b/ethcore/src/types/account_diff.rs @@ -80,9 +80,9 @@ pub enum Existance { impl fmt::Display for Existance { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { - Existance::Born => try!(write!(f, "+++")), - Existance::Alive => try!(write!(f, "***")), - Existance::Died => try!(write!(f, "XXX")), + Existance::Born => write!(f, "+++")?, + Existance::Alive => write!(f, "***")?, + Existance::Died => write!(f, "XXX")?, } Ok(()) } @@ -117,24 +117,24 @@ impl fmt::Display for AccountDiff { use util::bytes::ToPretty; match self.nonce { - Diff::Born(ref x) => try!(write!(f, " non {}", x)), - Diff::Changed(ref pre, ref post) => try!(write!(f, "#{} ({} {} {})", post, pre, if pre > post {"-"} else {"+"}, *max(pre, post) - * min(pre, post))), + Diff::Born(ref x) => write!(f, " non {}", x)?, + Diff::Changed(ref pre, ref post) => write!(f, "#{} ({} {} {})", post, pre, if pre > post {"-"} else {"+"}, *max(pre, post) - * min(pre, post))?, _ => {}, } match self.balance { - Diff::Born(ref x) => try!(write!(f, " bal {}", x)), - Diff::Changed(ref pre, ref post) => try!(write!(f, "${} ({} {} {})", post, pre, if pre > post {"-"} else {"+"}, *max(pre, post) - *min(pre, post))), + Diff::Born(ref x) => write!(f, " bal {}", x)?, + Diff::Changed(ref pre, ref post) => write!(f, "${} ({} {} {})", post, pre, if pre > post {"-"} else {"+"}, *max(pre, post) - *min(pre, post))?, _ => {}, } if let Diff::Born(ref x) = self.code { - try!(write!(f, " code {}", x.pretty())); + write!(f, " code {}", x.pretty())?; } - try!(write!(f, "\n")); + write!(f, "\n")?; for (k, dv) in &self.storage { match *dv { - Diff::Born(ref v) => try!(write!(f, " + {} => {}\n", interpreted_hash(k), interpreted_hash(v))), - Diff::Changed(ref pre, ref post) => try!(write!(f, " * {} => {} (was {})\n", interpreted_hash(k), interpreted_hash(post), interpreted_hash(pre))), - Diff::Died(_) => try!(write!(f, " X {}\n", interpreted_hash(k))), + Diff::Born(ref v) => write!(f, " + {} => {}\n", interpreted_hash(k), interpreted_hash(v))?, + Diff::Changed(ref pre, ref post) => write!(f, " * {} => {} (was {})\n", interpreted_hash(k), interpreted_hash(post), interpreted_hash(pre))?, + Diff::Died(_) => write!(f, " X {}\n", interpreted_hash(k))?, _ => {}, } } diff --git a/ethcore/src/types/log_entry.rs b/ethcore/src/types/log_entry.rs index 7407952ba..1fbb4305f 100644 --- a/ethcore/src/types/log_entry.rs +++ b/ethcore/src/types/log_entry.rs @@ -50,9 +50,9 @@ impl Decodable for LogEntry { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); let entry = LogEntry { - address: try!(d.val_at(0)), - topics: try!(d.val_at(1)), - data: try!(d.val_at(2)), + address: d.val_at(0)?, + topics: d.val_at(1)?, + data: d.val_at(2)?, }; Ok(entry) } diff --git a/ethcore/src/types/receipt.rs b/ethcore/src/types/receipt.rs index 524526ff6..4e28c55cc 100644 --- a/ethcore/src/types/receipt.rs +++ b/ethcore/src/types/receipt.rs @@ -64,10 +64,10 @@ impl Decodable for Receipt { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); let receipt = Receipt { - state_root: try!(d.val_at(0)), - gas_used: try!(d.val_at(1)), - log_bloom: try!(d.val_at(2)), - logs: try!(d.val_at(3)), + state_root: d.val_at(0)?, + gas_used: d.val_at(1)?, + log_bloom: d.val_at(2)?, + logs: d.val_at(3)?, }; Ok(receipt) } diff --git a/ethcore/src/types/snapshot_manifest.rs b/ethcore/src/types/snapshot_manifest.rs index 1c1e801cb..f3f189aed 100644 --- a/ethcore/src/types/snapshot_manifest.rs +++ b/ethcore/src/types/snapshot_manifest.rs @@ -53,11 +53,11 @@ impl ManifestData { pub fn from_rlp(raw: &[u8]) -> Result { let decoder = UntrustedRlp::new(raw); - let state_hashes: Vec = try!(decoder.val_at(0)); - let block_hashes: Vec = try!(decoder.val_at(1)); - let state_root: H256 = try!(decoder.val_at(2)); - let block_number: u64 = try!(decoder.val_at(3)); - let block_hash: H256 = try!(decoder.val_at(4)); + let state_hashes: Vec = decoder.val_at(0)?; + let block_hashes: Vec = decoder.val_at(1)?; + let state_root: H256 = decoder.val_at(2)?; + let block_number: u64 = decoder.val_at(3)?; + let block_hash: H256 = decoder.val_at(4)?; Ok(ManifestData { state_hashes: state_hashes, diff --git a/ethcore/src/types/state_diff.rs b/ethcore/src/types/state_diff.rs index cb3db1ba9..ad0b8c88e 100644 --- a/ethcore/src/types/state_diff.rs +++ b/ethcore/src/types/state_diff.rs @@ -41,7 +41,7 @@ impl StateDiff { impl fmt::Display for StateDiff { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { for (add, acc) in &self.raw { - try!(write!(f, "{} {}: {}", acc.existance(), add, acc)); + write!(f, "{} {}: {}", acc.existance(), add, acc)?; } Ok(()) } diff --git a/ethcore/src/types/trace_types/error.rs b/ethcore/src/types/trace_types/error.rs index 2294f673a..9b4ee900b 100644 --- a/ethcore/src/types/trace_types/error.rs +++ b/ethcore/src/types/trace_types/error.rs @@ -86,7 +86,7 @@ impl Encodable for Error { impl Decodable for Error { fn decode(decoder: &D) -> Result where D: Decoder { use self::Error::*; - let value: u8 = try!(decoder.as_rlp().as_val()); + let value: u8 = decoder.as_rlp().as_val()?; match value { 0 => Ok(OutOfGas), 1 => Ok(BadJumpDestination), diff --git a/ethcore/src/types/trace_types/flat.rs b/ethcore/src/types/trace_types/flat.rs index b79cabb49..78701eadb 100644 --- a/ethcore/src/types/trace_types/flat.rs +++ b/ethcore/src/types/trace_types/flat.rs @@ -66,11 +66,11 @@ impl Encodable for FlatTrace { impl Decodable for FlatTrace { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); - let v: Vec = try!(d.val_at(3)); + let v: Vec = d.val_at(3)?; let res = FlatTrace { - action: try!(d.val_at(0)), - result: try!(d.val_at(1)), - subtraces: try!(d.val_at(2)), + action: d.val_at(0)?, + result: d.val_at(1)?, + subtraces: d.val_at(2)?, trace_address: v.into_iter().collect(), }; @@ -109,7 +109,7 @@ impl Encodable for FlatTransactionTraces { impl Decodable for FlatTransactionTraces { fn decode(decoder: &D) -> Result where D: Decoder { - Ok(FlatTransactionTraces(try!(Decodable::decode(decoder)))) + Ok(FlatTransactionTraces(Decodable::decode(decoder)?)) } } @@ -150,7 +150,7 @@ impl Encodable for FlatBlockTraces { impl Decodable for FlatBlockTraces { fn decode(decoder: &D) -> Result where D: Decoder { - Ok(FlatBlockTraces(try!(Decodable::decode(decoder)))) + Ok(FlatBlockTraces(Decodable::decode(decoder)?)) } } diff --git a/ethcore/src/types/trace_types/trace.rs b/ethcore/src/types/trace_types/trace.rs index 55494c533..2636caa52 100644 --- a/ethcore/src/types/trace_types/trace.rs +++ b/ethcore/src/types/trace_types/trace.rs @@ -48,8 +48,8 @@ impl Decodable for CallResult { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); let res = CallResult { - gas_used: try!(d.val_at(0)), - output: try!(d.val_at(1)), + gas_used: d.val_at(0)?, + output: d.val_at(1)?, }; Ok(res) @@ -81,9 +81,9 @@ impl Decodable for CreateResult { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); let res = CreateResult { - gas_used: try!(d.val_at(0)), - code: try!(d.val_at(1)), - address: try!(d.val_at(2)), + gas_used: d.val_at(0)?, + code: d.val_at(1)?, + address: d.val_at(2)?, }; Ok(res) @@ -144,12 +144,12 @@ impl Decodable for Call { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); let res = Call { - from: try!(d.val_at(0)), - to: try!(d.val_at(1)), - value: try!(d.val_at(2)), - gas: try!(d.val_at(3)), - input: try!(d.val_at(4)), - call_type: try!(d.val_at(5)), + from: d.val_at(0)?, + to: d.val_at(1)?, + value: d.val_at(2)?, + gas: d.val_at(3)?, + input: d.val_at(4)?, + call_type: d.val_at(5)?, }; Ok(res) @@ -204,10 +204,10 @@ impl Decodable for Create { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); let res = Create { - from: try!(d.val_at(0)), - value: try!(d.val_at(1)), - gas: try!(d.val_at(2)), - init: try!(d.val_at(3)), + from: d.val_at(0)?, + value: d.val_at(1)?, + gas: d.val_at(2)?, + init: d.val_at(3)?, }; Ok(res) @@ -255,9 +255,9 @@ impl Decodable for Suicide { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); let res = Suicide { - address: try!(d.val_at(0)), - refund_address: try!(d.val_at(1)), - balance: try!(d.val_at(2)), + address: d.val_at(0)?, + refund_address: d.val_at(1)?, + balance: d.val_at(2)?, }; Ok(res) @@ -300,7 +300,7 @@ impl Encodable for Action { impl Decodable for Action { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); - let action_type: u8 = try!(d.val_at(0)); + let action_type: u8 = d.val_at(0)?; match action_type { 0 => d.val_at(1).map(Action::Call), 1 => d.val_at(1).map(Action::Create), @@ -371,7 +371,7 @@ impl Encodable for Res { impl Decodable for Res { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); - let action_type: u8 = try!(d.val_at(0)); + let action_type: u8 = d.val_at(0)?; match action_type { 0 => d.val_at(1).map(Res::Call), 1 => d.val_at(1).map(Res::Create), @@ -415,8 +415,8 @@ impl Decodable for MemoryDiff { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); Ok(MemoryDiff { - offset: try!(d.val_at(0)), - data: try!(d.val_at(1)), + offset: d.val_at(0)?, + data: d.val_at(1)?, }) } } @@ -443,8 +443,8 @@ impl Decodable for StorageDiff { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); Ok(StorageDiff { - location: try!(d.val_at(0)), - value: try!(d.val_at(1)), + location: d.val_at(0)?, + value: d.val_at(1)?, }) } } @@ -477,10 +477,10 @@ impl Decodable for VMExecutedOperation { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); Ok(VMExecutedOperation { - gas_used: try!(d.val_at(0)), - stack_push: try!(d.val_at(1)), - mem_diff: try!(d.val_at(2)), - store_diff: try!(d.val_at(3)), + gas_used: d.val_at(0)?, + stack_push: d.val_at(1)?, + mem_diff: d.val_at(2)?, + store_diff: d.val_at(3)?, }) } } @@ -513,10 +513,10 @@ impl Decodable for VMOperation { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); let res = VMOperation { - pc: try!(d.val_at(0)), - instruction: try!(d.val_at(1)), - gas_cost: try!(d.val_at(2)), - executed: try!(d.val_at(3)), + pc: d.val_at(0)?, + instruction: d.val_at(1)?, + gas_cost: d.val_at(2)?, + executed: d.val_at(3)?, }; Ok(res) @@ -552,10 +552,10 @@ impl Decodable for VMTrace { fn decode(decoder: &D) -> Result where D: Decoder { let d = decoder.as_rlp(); let res = VMTrace { - parent_step: try!(d.val_at(0)), - code: try!(d.val_at(1)), - operations: try!(d.val_at(2)), - subs: try!(d.val_at(3)), + parent_step: d.val_at(0)?, + code: d.val_at(1)?, + operations: d.val_at(2)?, + subs: d.val_at(3)?, }; Ok(res) diff --git a/ethcore/src/types/transaction.rs b/ethcore/src/types/transaction.rs index 32fe9acab..77a6a99a9 100644 --- a/ethcore/src/types/transaction.rs +++ b/ethcore/src/types/transaction.rs @@ -48,7 +48,7 @@ impl Decodable for Action { if rlp.is_empty() { Ok(Action::Create) } else { - Ok(Action::Call(try!(rlp.as_val()))) + Ok(Action::Call(rlp.as_val()?)) } } } @@ -247,16 +247,16 @@ impl Decodable for SignedTransaction { } Ok(SignedTransaction { unsigned: Transaction { - nonce: try!(d.val_at(0)), - gas_price: try!(d.val_at(1)), - gas: try!(d.val_at(2)), - action: try!(d.val_at(3)), - value: try!(d.val_at(4)), - data: try!(d.val_at(5)), + nonce: d.val_at(0)?, + gas_price: d.val_at(1)?, + gas: d.val_at(2)?, + action: d.val_at(3)?, + value: d.val_at(4)?, + data: d.val_at(5)?, }, - v: try!(d.val_at(6)), - r: try!(d.val_at(7)), - s: try!(d.val_at(8)), + v: d.val_at(6)?, + r: d.val_at(7)?, + s: d.val_at(8)?, hash: Cell::new(None), sender: Cell::new(None), }) @@ -338,7 +338,7 @@ impl SignedTransaction { match sender { Some(s) => Ok(s), None => { - let s = public_to_address(&try!(self.public_key())); + let s = public_to_address(&self.public_key()?); self.sender.set(Some(s)); Ok(s) } @@ -347,7 +347,7 @@ impl SignedTransaction { /// Returns the public key of the sender. pub fn public_key(&self) -> Result { - Ok(try!(recover(&self.signature(), &self.unsigned.hash(self.network_id())))) + Ok(recover(&self.signature(), &self.unsigned.hash(self.network_id()))?) } /// Do basic validation, checking for valid signature and minimum gas, @@ -363,7 +363,7 @@ impl SignedTransaction { Some(1) if allow_network_id_of_one => {}, _ => return Err(TransactionError::InvalidNetworkId.into()), } - try!(self.sender()); + self.sender()?; if self.gas < U256::from(self.gas_required(&schedule)) { Err(TransactionError::InvalidGasLimit(::util::OutOfBounds{min: Some(U256::from(self.gas_required(&schedule))), max: None, found: self.gas}).into()) } else { diff --git a/ethcore/src/verification/verification.rs b/ethcore/src/verification/verification.rs index 661c40c96..bbdf3c0c1 100644 --- a/ethcore/src/verification/verification.rs +++ b/ethcore/src/verification/verification.rs @@ -51,19 +51,19 @@ impl HeapSizeOf for PreverifiedBlock { /// Phase 1 quick block verification. Only does checks that are cheap. Operates on a single block pub fn verify_block_basic(header: &Header, bytes: &[u8], engine: &Engine) -> Result<(), Error> { - try!(verify_header_params(&header, engine)); - try!(verify_block_integrity(bytes, &header.transactions_root(), &header.uncles_hash())); - try!(engine.verify_block_basic(&header, Some(bytes))); - for u in try!(UntrustedRlp::new(bytes).at(2)).iter().map(|rlp| rlp.as_val::
()) { - let u = try!(u); - try!(verify_header_params(&u, engine)); - try!(engine.verify_block_basic(&u, None)); + verify_header_params(&header, engine)?; + verify_block_integrity(bytes, &header.transactions_root(), &header.uncles_hash())?; + engine.verify_block_basic(&header, Some(bytes))?; + for u in UntrustedRlp::new(bytes).at(2)?.iter().map(|rlp| rlp.as_val::
()) { + let u = u?; + verify_header_params(&u, engine)?; + engine.verify_block_basic(&u, None)?; } // Verify transactions. // TODO: either use transaction views or cache the decoded transactions. let v = BlockView::new(bytes); for t in v.transactions() { - try!(engine.verify_transaction_basic(&t, &header)); + engine.verify_transaction_basic(&t, &header)?; } Ok(()) } @@ -73,9 +73,9 @@ pub fn verify_block_basic(header: &Header, bytes: &[u8], engine: &Engine) -> Res /// Returns a `PreverifiedBlock` structure populated with transactions pub fn verify_block_unordered(header: Header, bytes: Bytes, engine: &Engine, check_seal: bool) -> Result { if check_seal { - try!(engine.verify_block_unordered(&header, Some(&bytes))); - for u in try!(UntrustedRlp::new(&bytes).at(2)).iter().map(|rlp| rlp.as_val::
()) { - try!(engine.verify_block_unordered(&try!(u), None)); + engine.verify_block_unordered(&header, Some(&bytes))?; + for u in UntrustedRlp::new(&bytes).at(2)?.iter().map(|rlp| rlp.as_val::
()) { + engine.verify_block_unordered(&u?, None)?; } } // Verify transactions. @@ -83,7 +83,7 @@ pub fn verify_block_unordered(header: Header, bytes: Bytes, engine: &Engine, che { let v = BlockView::new(&bytes); for t in v.transactions() { - try!(engine.verify_transaction(&t, &header)); + engine.verify_transaction(&t, &header)?; transactions.push(t); } } @@ -97,11 +97,11 @@ pub fn verify_block_unordered(header: Header, bytes: Bytes, engine: &Engine, che /// Phase 3 verification. Check block information against parent and uncles. pub fn verify_block_family(header: &Header, bytes: &[u8], engine: &Engine, bc: &BlockProvider) -> Result<(), Error> { // TODO: verify timestamp - let parent = try!(bc.block_header(&header.parent_hash()).ok_or_else(|| Error::from(BlockError::UnknownParent(header.parent_hash().clone())))); - try!(verify_parent(&header, &parent)); - try!(engine.verify_block_family(&header, &parent, Some(bytes))); + let parent = bc.block_header(&header.parent_hash()).ok_or_else(|| Error::from(BlockError::UnknownParent(header.parent_hash().clone())))?; + verify_parent(&header, &parent)?; + engine.verify_block_family(&header, &parent, Some(bytes))?; - let num_uncles = try!(UntrustedRlp::new(bytes).at(2)).item_count(); + let num_uncles = UntrustedRlp::new(bytes).at(2)?.item_count(); if num_uncles != 0 { if num_uncles > engine.maximum_uncle_count() { return Err(From::from(BlockError::TooManyUncles(OutOfBounds { min: None, max: Some(engine.maximum_uncle_count()), found: num_uncles }))); @@ -124,8 +124,8 @@ pub fn verify_block_family(header: &Header, bytes: &[u8], engine: &Engine, bc: & } } - for uncle in try!(UntrustedRlp::new(bytes).at(2)).iter().map(|rlp| rlp.as_val::
()) { - let uncle = try!(uncle); + for uncle in UntrustedRlp::new(bytes).at(2)?.iter().map(|rlp| rlp.as_val::
()) { + let uncle = uncle?; if excluded.contains(&uncle.hash()) { return Err(From::from(BlockError::UncleInChain(uncle.hash()))) } @@ -157,7 +157,7 @@ pub fn verify_block_family(header: &Header, bytes: &[u8], engine: &Engine, bc: & // cB.p^7 -------------/ // cB.p^8 let mut expected_uncle_parent = header.parent_hash().clone(); - let uncle_parent = try!(bc.block_header(&uncle.parent_hash()).ok_or_else(|| Error::from(BlockError::UnknownUncleParent(uncle.parent_hash().clone())))); + let uncle_parent = bc.block_header(&uncle.parent_hash()).ok_or_else(|| Error::from(BlockError::UnknownUncleParent(uncle.parent_hash().clone())))?; for _ in 0..depth { match bc.block_details(&expected_uncle_parent) { Some(details) => { @@ -170,8 +170,8 @@ pub fn verify_block_family(header: &Header, bytes: &[u8], engine: &Engine, bc: & return Err(From::from(BlockError::UncleParentNotInChain(uncle_parent.hash()))); } - try!(verify_parent(&uncle, &uncle_parent)); - try!(engine.verify_block_family(&uncle, &uncle_parent, Some(bytes))); + verify_parent(&uncle, &uncle_parent)?; + engine.verify_block_family(&uncle, &uncle_parent, Some(bytes))?; } } Ok(()) @@ -234,12 +234,12 @@ fn verify_parent(header: &Header, parent: &Header) -> Result<(), Error> { /// Verify block data against header: transactions root and uncles hash. fn verify_block_integrity(block: &[u8], transactions_root: &H256, uncles_hash: &H256) -> Result<(), Error> { let block = UntrustedRlp::new(block); - let tx = try!(block.at(1)); + let tx = block.at(1)?; let expected_root = &ordered_trie_root(tx.iter().map(|r| r.as_raw().to_vec())); //TODO: get rid of vectors here if expected_root != transactions_root { return Err(From::from(BlockError::InvalidTransactionsRoot(Mismatch { expected: expected_root.clone(), found: transactions_root.clone() }))) } - let expected_uncles = &try!(block.at(2)).as_raw().sha3(); + let expected_uncles = &block.at(2)?.as_raw().sha3(); if expected_uncles != uncles_hash { return Err(From::from(BlockError::InvalidUnclesHash(Mismatch { expected: expected_uncles.clone(), found: uncles_hash.clone() }))) } diff --git a/ethcrypto/src/lib.rs b/ethcrypto/src/lib.rs index 4cb086365..4053baa9f 100644 --- a/ethcrypto/src/lib.rs +++ b/ethcrypto/src/lib.rs @@ -158,7 +158,7 @@ pub mod aes { let mut encryptor = CbcDecryptor::new(AesSafe128Decryptor::new(k), PkcsPadding, iv.to_vec()); let len = dest.len(); let mut buffer = RefWriteBuffer::new(dest); - try!(encryptor.decrypt(&mut RefReadBuffer::new(encrypted), &mut buffer, true)); + encryptor.decrypt(&mut RefReadBuffer::new(encrypted), &mut buffer, true)?; Ok(len - buffer.remaining()) } } @@ -179,7 +179,7 @@ pub mod ecdh { temp }; - let publ = try!(key::PublicKey::from_slice(context, &pdata)); + let publ = key::PublicKey::from_slice(context, &pdata)?; // no way to create SecretKey from raw byte array. let sec: &key::SecretKey = unsafe { ::std::mem::transmute(secret) }; let shared = ecdh::SharedSecret::new_raw(context, &publ, sec); @@ -206,7 +206,7 @@ pub mod ecies { let r = Random.generate() .expect("context known to have key-generation capabilities; qed"); - let z = try!(ecdh::agree(r.secret(), public)); + let z = ecdh::agree(r.secret(), public)?; let mut key = [0u8; 32]; let mut mkey = [0u8; 32]; kdf(&z, &[0u8; 0], &mut key); @@ -243,7 +243,7 @@ pub mod ecies { let r = Random.generate() .expect("context known to have key-generation capabilities"); - let z = try!(ecdh::agree(r.secret(), public)); + let z = ecdh::agree(r.secret(), public)?; let mut key = [0u8; 32]; let mut mkey = [0u8; 32]; kdf(&z, &[0u8; 0], &mut key); @@ -274,7 +274,7 @@ pub mod ecies { let e = &encrypted[1..]; let p = Public::from_slice(&e[0..64]); - let z = try!(ecdh::agree(secret, &p)); + let z = ecdh::agree(secret, &p)?; let mut key = [0u8; 32]; kdf(&z, &[0u8; 0], &mut key); let ekey = &key[0..16]; @@ -314,7 +314,7 @@ pub mod ecies { let e = encrypted; let p = Public::from_slice(&e[0..64]); - let z = try!(ecdh::agree(secret, &p)); + let z = ecdh::agree(secret, &p)?; let mut key = [0u8; 32]; kdf(&z, &[0u8; 0], &mut key); let ekey = &key[0..16]; diff --git a/ethkey/src/bin/ethkey.rs b/ethkey/src/bin/ethkey.rs index af301732b..d1d15c94f 100644 --- a/ethkey/src/bin/ethkey.rs +++ b/ethkey/src/bin/ethkey.rs @@ -160,37 +160,37 @@ fn execute(command: I) -> Result where I: IntoIterator Result<(), fmt::Error> { - try!(writeln!(f, "secret: {}", self.secret.to_hex())); - try!(writeln!(f, "public: {}", self.public.to_hex())); + writeln!(f, "secret: {}", self.secret.to_hex())?; + writeln!(f, "public: {}", self.public.to_hex())?; write!(f, "address: {}", self.address().to_hex()) } } @@ -45,8 +45,8 @@ impl KeyPair { /// Create a pair from secret key pub fn from_secret(secret: Secret) -> Result { let context = &SECP256K1; - let s: key::SecretKey = try!(key::SecretKey::from_slice(context, &secret[..])); - let pub_key = try!(key::PublicKey::from_secret_key(context, &s)); + let s: key::SecretKey = key::SecretKey::from_slice(context, &secret[..])?; + let pub_key = key::PublicKey::from_secret_key(context, &s)?; let serialized = pub_key.serialize_vec(context, false); let mut public = Public::default(); diff --git a/ethkey/src/prefix.rs b/ethkey/src/prefix.rs index 59e64abda..91c24708d 100644 --- a/ethkey/src/prefix.rs +++ b/ethkey/src/prefix.rs @@ -34,7 +34,7 @@ impl Prefix { impl Generator for Prefix { fn generate(self) -> Result { for _ in 0..self.iterations { - let keypair = try!(Random.generate()); + let keypair = Random.generate()?; if keypair.address().starts_with(&self.prefix) { return Ok(keypair) } diff --git a/ethkey/src/random.rs b/ethkey/src/random.rs index 8b0c98c64..f17651c0a 100644 --- a/ethkey/src/random.rs +++ b/ethkey/src/random.rs @@ -23,8 +23,8 @@ pub struct Random; impl Generator for Random { fn generate(self) -> Result { let context = &SECP256K1; - let mut rng = try!(OsRng::new()); - let (sec, publ) = try!(context.generate_keypair(&mut rng)); + let mut rng = OsRng::new()?; + let (sec, publ) = context.generate_keypair(&mut rng)?; Ok(KeyPair::from_keypair(sec, publ)) } diff --git a/ethkey/src/signature.rs b/ethkey/src/signature.rs index ad595cfb9..ef28fb408 100644 --- a/ethkey/src/signature.rs +++ b/ethkey/src/signature.rs @@ -171,7 +171,7 @@ pub fn sign(secret: &Secret, message: &Message) -> Result { let context = &SECP256K1; // no way to create from raw byte array. let sec: &SecretKey = unsafe { mem::transmute(secret) }; - let s = try!(context.sign_recoverable(&try!(SecpMessage::from_slice(&message[..])), sec)); + let s = context.sign_recoverable(&SecpMessage::from_slice(&message[..])?, sec)?; let (rec_id, data) = s.serialize_compact(context); let mut data_arr = [0; 65]; @@ -183,7 +183,7 @@ pub fn sign(secret: &Secret, message: &Message) -> Result { pub fn verify_public(public: &Public, signature: &Signature, message: &Message) -> Result { let context = &SECP256K1; - let rsig = try!(RecoverableSignature::from_compact(context, &signature[0..64], try!(RecoveryId::from_i32(signature[64] as i32)))); + let rsig = RecoverableSignature::from_compact(context, &signature[0..64], RecoveryId::from_i32(signature[64] as i32)?)?; let sig = rsig.to_standard(context); let pdata: [u8; 65] = { @@ -192,8 +192,8 @@ pub fn verify_public(public: &Public, signature: &Signature, message: &Message) temp }; - let publ = try!(PublicKey::from_slice(context, &pdata)); - match context.verify(&try!(SecpMessage::from_slice(&message[..])), &sig, &publ) { + let publ = PublicKey::from_slice(context, &pdata)?; + match context.verify(&SecpMessage::from_slice(&message[..])?, &sig, &publ) { Ok(_) => Ok(true), Err(SecpError::IncorrectSignature) => Ok(false), Err(x) => Err(Error::from(x)) @@ -201,15 +201,15 @@ pub fn verify_public(public: &Public, signature: &Signature, message: &Message) } pub fn verify_address(address: &Address, signature: &Signature, message: &Message) -> Result { - let public = try!(recover(signature, message)); + let public = recover(signature, message)?; let recovered_address = public_to_address(&public); Ok(address == &recovered_address) } pub fn recover(signature: &Signature, message: &Message) -> Result { let context = &SECP256K1; - let rsig = try!(RecoverableSignature::from_compact(context, &signature[0..64], try!(RecoveryId::from_i32(signature[64] as i32)))); - let pubkey = try!(context.recover(&try!(SecpMessage::from_slice(&message[..])), &rsig)); + let rsig = RecoverableSignature::from_compact(context, &signature[0..64], RecoveryId::from_i32(signature[64] as i32)?)?; + let pubkey = context.recover(&SecpMessage::from_slice(&message[..])?, &rsig)?; let serialized = pubkey.serialize_vec(context, false); let mut public = Public::default(); diff --git a/ethstore/src/account/safe_account.rs b/ethstore/src/account/safe_account.rs index 133e6eeac..76da94021 100644 --- a/ethstore/src/account/safe_account.rs +++ b/ethstore/src/account/safe_account.rs @@ -113,7 +113,7 @@ impl Crypto { let (derived_left_bits, derived_right_bits) = match self.kdf { Kdf::Pbkdf2(ref params) => crypto::derive_key_iterations(password, ¶ms.salt, params.c), - Kdf::Scrypt(ref params) => try!(crypto::derive_key_scrypt(password, ¶ms.salt, params.n, params.p, params.r)), + Kdf::Scrypt(ref params) => crypto::derive_key_scrypt(password, ¶ms.salt, params.n, params.p, params.r)?, }; let mac = crypto::derive_mac(&derived_right_bits, &self.ciphertext).keccak256(); @@ -171,22 +171,22 @@ impl SafeAccount { } pub fn sign(&self, password: &str, message: &Message) -> Result { - let secret = try!(self.crypto.secret(password)); + let secret = self.crypto.secret(password)?; sign(&secret, message).map_err(From::from) } pub fn decrypt(&self, password: &str, shared_mac: &[u8], message: &[u8]) -> Result, Error> { - let secret = try!(self.crypto.secret(password)); + let secret = self.crypto.secret(password)?; crypto::ecies::decrypt(&secret, shared_mac, message).map_err(From::from) } pub fn public(&self, password: &str) -> Result { - let secret = try!(self.crypto.secret(password)); - Ok(try!(KeyPair::from_secret(secret)).public().clone()) + let secret = self.crypto.secret(password)?; + Ok(KeyPair::from_secret(secret)?.public().clone()) } pub fn change_password(&self, old_password: &str, new_password: &str, iterations: u32) -> Result { - let secret = try!(self.crypto.secret(old_password)); + let secret = self.crypto.secret(old_password)?; let result = SafeAccount { id: self.id.clone(), version: self.version.clone(), diff --git a/ethstore/src/bin/ethstore.rs b/ethstore/src/bin/ethstore.rs index 954be2aa9..18f8befec 100644 --- a/ethstore/src/bin/ethstore.rs +++ b/ethstore/src/bin/ethstore.rs @@ -93,11 +93,11 @@ fn main() { fn key_dir(location: &str) -> Result, Error> { let dir: Box = match location { - "parity" => Box::new(try!(ParityDirectory::create(DirectoryType::Main))), - "parity-test" => Box::new(try!(ParityDirectory::create(DirectoryType::Testnet))), - "geth" => Box::new(try!(GethDirectory::create(DirectoryType::Main))), - "geth-test" => Box::new(try!(GethDirectory::create(DirectoryType::Testnet))), - path => Box::new(try!(DiskDirectory::create(path))), + "parity" => Box::new(ParityDirectory::create(DirectoryType::Main)?), + "parity-test" => Box::new(ParityDirectory::create(DirectoryType::Testnet)?), + "geth" => Box::new(GethDirectory::create(DirectoryType::Main)?), + "geth-test" => Box::new(GethDirectory::create(DirectoryType::Testnet)?), + path => Box::new(DiskDirectory::create(path)?), }; Ok(dir) @@ -112,9 +112,9 @@ fn format_accounts(accounts: &[Address]) -> String { } fn load_password(path: &str) -> Result { - let mut file = try!(fs::File::open(path)); + let mut file = fs::File::open(path)?; let mut password = String::new(); - try!(file.read_to_string(&mut password)); + file.read_to_string(&mut password)?; // drop EOF let _ = password.pop(); Ok(password) @@ -125,48 +125,48 @@ fn execute(command: I) -> Result where I: IntoIterator Result<(), i32> { use std::ffi; use libc; - let cstr = try!(ffi::CString::new(&*file_path.to_string_lossy()) - .map_err(|_| -1)); + let cstr = ffi::CString::new(&*file_path.to_string_lossy()) + .map_err(|_| -1)?; match unsafe { libc::chmod(cstr.as_ptr(), libc::S_IWUSR | libc::S_IRUSR) } { 0 => Ok(()), x => Err(x), @@ -48,7 +48,7 @@ pub struct DiskDirectory { impl DiskDirectory { pub fn create

(path: P) -> Result where P: AsRef { - try!(fs::create_dir_all(&path)); + fs::create_dir_all(&path)?; Ok(Self::at(path)) } @@ -62,7 +62,7 @@ impl DiskDirectory { fn files(&self) -> Result, Error> { // it's not done using one iterator cause // there is an issue with rustc and it takes tooo much time to compile - let paths = try!(fs::read_dir(&self.path)) + let paths = fs::read_dir(&self.path)? .flat_map(Result::ok) .filter(|entry| { let metadata = entry.metadata().ok(); @@ -102,7 +102,7 @@ impl DiskDirectory { impl KeyDirectory for DiskDirectory { fn load(&self) -> Result, Error> { - let accounts = try!(self.files()) + let accounts = self.files()? .into_iter() .map(|(_, account)| account) .collect(); @@ -134,8 +134,8 @@ impl KeyDirectory for DiskDirectory { keyfile_path.push(filename.as_str()); // save the file - let mut file = try!(fs::File::create(&keyfile_path)); - try!(keyfile.write(&mut file).map_err(|e| Error::Custom(format!("{:?}", e)))); + let mut file = fs::File::create(&keyfile_path)?; + keyfile.write(&mut file).map_err(|e| Error::Custom(format!("{:?}", e)))?; if let Err(_) = restrict_permissions_to_owner(keyfile_path.as_path()) { fs::remove_file(keyfile_path).expect("Expected to remove recently created file"); @@ -149,7 +149,7 @@ impl KeyDirectory for DiskDirectory { fn remove(&self, account: &SafeAccount) -> Result<(), Error> { // enumerate all entries in keystore // and find entry with given address - let to_remove = try!(self.files()) + let to_remove = self.files()? .into_iter() .find(|&(_, ref acc)| acc == account); diff --git a/ethstore/src/dir/geth.rs b/ethstore/src/dir/geth.rs index fe2ba8d1d..929ee00d9 100644 --- a/ethstore/src/dir/geth.rs +++ b/ethstore/src/dir/geth.rs @@ -66,7 +66,7 @@ pub struct GethDirectory { impl GethDirectory { pub fn create(t: DirectoryType) -> Result { let result = GethDirectory { - dir: try!(DiskDirectory::create(geth_keystore(t))), + dir: DiskDirectory::create(geth_keystore(t))?, }; Ok(result) diff --git a/ethstore/src/dir/parity.rs b/ethstore/src/dir/parity.rs index 75c21ea13..e381cd9a4 100644 --- a/ethstore/src/dir/parity.rs +++ b/ethstore/src/dir/parity.rs @@ -45,7 +45,7 @@ pub struct ParityDirectory { impl ParityDirectory { pub fn create(t: DirectoryType) -> Result { let result = ParityDirectory { - dir: try!(DiskDirectory::create(parity_keystore(t))), + dir: DiskDirectory::create(parity_keystore(t))?, }; Ok(result) diff --git a/ethstore/src/ethstore.rs b/ethstore/src/ethstore.rs index e100594de..0747ee157 100644 --- a/ethstore/src/ethstore.rs +++ b/ethstore/src/ethstore.rs @@ -38,12 +38,12 @@ impl EthStore { pub fn open_with_iterations(directory: Box, iterations: u32) -> Result { Ok(EthStore { - store: try!(EthMultiStore::open_with_iterations(directory, iterations)), + store: EthMultiStore::open_with_iterations(directory, iterations)?, }) } fn get(&self, address: &Address) -> Result { - let mut accounts = try!(self.store.get(address)).into_iter(); + let mut accounts = self.store.get(address)?.into_iter(); accounts.next().ok_or(Error::InvalidAccount) } } @@ -66,68 +66,68 @@ impl SimpleSecretStore for EthStore { } fn sign(&self, address: &Address, password: &str, message: &Message) -> Result { - let account = try!(self.get(address)); + let account = self.get(address)?; account.sign(password, message) } fn decrypt(&self, account: &Address, password: &str, shared_mac: &[u8], message: &[u8]) -> Result, Error> { - let account = try!(self.get(account)); + let account = self.get(account)?; account.decrypt(password, shared_mac, message) } } impl SecretStore for EthStore { fn import_presale(&self, json: &[u8], password: &str) -> Result { - let json_wallet = try!(json::PresaleWallet::load(json).map_err(|_| Error::InvalidKeyFile("Invalid JSON format".to_owned()))); + let json_wallet = json::PresaleWallet::load(json).map_err(|_| Error::InvalidKeyFile("Invalid JSON format".to_owned()))?; let wallet = PresaleWallet::from(json_wallet); - let keypair = try!(wallet.decrypt(password).map_err(|_| Error::InvalidPassword)); + let keypair = wallet.decrypt(password).map_err(|_| Error::InvalidPassword)?; self.insert_account(keypair.secret().clone(), password) } fn import_wallet(&self, json: &[u8], password: &str) -> Result { - let json_keyfile = try!(json::KeyFile::load(json).map_err(|_| Error::InvalidKeyFile("Invalid JSON format".to_owned()))); + let json_keyfile = json::KeyFile::load(json).map_err(|_| Error::InvalidKeyFile("Invalid JSON format".to_owned()))?; let mut safe_account = SafeAccount::from_file(json_keyfile, None); - let secret = try!(safe_account.crypto.secret(password).map_err(|_| Error::InvalidPassword)); - safe_account.address = try!(KeyPair::from_secret(secret)).address(); + let secret = safe_account.crypto.secret(password).map_err(|_| Error::InvalidPassword)?; + safe_account.address = KeyPair::from_secret(secret)?.address(); let address = safe_account.address.clone(); - try!(self.store.import(safe_account)); + self.store.import(safe_account)?; Ok(address) } fn test_password(&self, address: &Address, password: &str) -> Result { - let account = try!(self.get(address)); + let account = self.get(address)?; Ok(account.check_password(password)) } fn copy_account(&self, new_store: &SimpleSecretStore, address: &Address, password: &str, new_password: &str) -> Result<(), Error> { - let account = try!(self.get(address)); - let secret = try!(account.crypto.secret(password)); - try!(new_store.insert_account(secret, new_password)); + let account = self.get(address)?; + let secret = account.crypto.secret(password)?; + new_store.insert_account(secret, new_password)?; Ok(()) } fn public(&self, account: &Address, password: &str) -> Result { - let account = try!(self.get(account)); + let account = self.get(account)?; account.public(password) } fn uuid(&self, address: &Address) -> Result { - let account = try!(self.get(address)); + let account = self.get(address)?; Ok(account.id.into()) } fn name(&self, address: &Address) -> Result { - let account = try!(self.get(address)); + let account = self.get(address)?; Ok(account.name.clone()) } fn meta(&self, address: &Address) -> Result { - let account = try!(self.get(address)); + let account = self.get(address)?; Ok(account.meta.clone()) } fn set_name(&self, address: &Address, name: String) -> Result<(), Error> { - let old = try!(self.get(address)); + let old = self.get(address)?; let mut account = old.clone(); account.name = name; @@ -136,7 +136,7 @@ impl SecretStore for EthStore { } fn set_meta(&self, address: &Address, meta: String) -> Result<(), Error> { - let old = try!(self.get(address)); + let old = self.get(address)?; let mut account = old.clone(); account.meta = meta; @@ -176,13 +176,13 @@ impl EthMultiStore { iterations: iterations, cache: Default::default(), }; - try!(store.reload_accounts()); + store.reload_accounts()?; Ok(store) } fn reload_accounts(&self) -> Result<(), Error> { let mut cache = self.cache.write(); - let accounts = try!(self.dir.load()); + let accounts = self.dir.load()?; let mut new_accounts = BTreeMap::new(); for account in accounts { @@ -203,9 +203,9 @@ impl EthMultiStore { } } - try!(self.reload_accounts()); + self.reload_accounts()?; let cache = self.cache.read(); - let accounts = try!(cache.get(address).cloned().ok_or(Error::InvalidAccount)); + let accounts = cache.get(address).cloned().ok_or(Error::InvalidAccount)?; if accounts.is_empty() { Err(Error::InvalidAccount) } else { @@ -215,7 +215,7 @@ impl EthMultiStore { fn import(&self, account: SafeAccount) -> Result<(), Error> { // save to file - let account = try!(self.dir.insert(account)); + let account = self.dir.insert(account)?; // update cache let mut cache = self.cache.write(); @@ -226,7 +226,7 @@ impl EthMultiStore { fn update(&self, old: SafeAccount, new: SafeAccount) -> Result<(), Error> { // save to file - let account = try!(self.dir.update(new)); + let account = self.dir.update(new)?; // update cache let mut cache = self.cache.write(); @@ -243,21 +243,21 @@ impl EthMultiStore { impl SimpleSecretStore for EthMultiStore { fn insert_account(&self, secret: Secret, password: &str) -> Result { - let keypair = try!(KeyPair::from_secret(secret).map_err(|_| Error::CreationFailed)); + let keypair = KeyPair::from_secret(secret).map_err(|_| Error::CreationFailed)?; let id: [u8; 16] = Random::random(); let account = SafeAccount::create(&keypair, id, password, self.iterations, "".to_owned(), "{}".to_owned()); let address = account.address.clone(); - try!(self.import(account)); + self.import(account)?; Ok(address) } fn accounts(&self) -> Result, Error> { - try!(self.reload_accounts()); + self.reload_accounts()?; Ok(self.cache.read().keys().cloned().collect()) } fn remove_account(&self, address: &Address, password: &str) -> Result<(), Error> { - let accounts = try!(self.get(address)); + let accounts = self.get(address)?; for account in accounts { // Skip if password is invalid @@ -266,7 +266,7 @@ impl SimpleSecretStore for EthMultiStore { } // Remove from dir - try!(self.dir.remove(&account)); + self.dir.remove(&account)?; // Remove from cache let mut cache = self.cache.write(); @@ -288,17 +288,17 @@ impl SimpleSecretStore for EthMultiStore { } fn change_password(&self, address: &Address, old_password: &str, new_password: &str) -> Result<(), Error> { - let accounts = try!(self.get(address)); + let accounts = self.get(address)?; for account in accounts { // Change password - let new_account = try!(account.change_password(old_password, new_password, self.iterations)); - try!(self.update(account, new_account)); + let new_account = account.change_password(old_password, new_password, self.iterations)?; + self.update(account, new_account)?; } Ok(()) } fn sign(&self, address: &Address, password: &str, message: &Message) -> Result { - let accounts = try!(self.get(address)); + let accounts = self.get(address)?; for account in accounts { if account.check_password(password) { return account.sign(password, message); @@ -309,7 +309,7 @@ impl SimpleSecretStore for EthMultiStore { } fn decrypt(&self, account: &Address, password: &str, shared_mac: &[u8], message: &[u8]) -> Result, Error> { - let accounts = try!(self.get(account)); + let accounts = self.get(account)?; for account in accounts { if account.check_password(password) { return account.decrypt(password, shared_mac, message); diff --git a/ethstore/src/import.rs b/ethstore/src/import.rs index b112bce75..863c7774b 100644 --- a/ethstore/src/import.rs +++ b/ethstore/src/import.rs @@ -20,14 +20,14 @@ use dir::{GethDirectory, KeyDirectory, DirectoryType}; use Error; pub fn import_accounts(src: &KeyDirectory, dst: &KeyDirectory) -> Result, Error> { - let accounts = try!(src.load()); - let existing_accounts = try!(dst.load()).into_iter().map(|a| a.address).collect::>(); + let accounts = src.load()?; + let existing_accounts = dst.load()?.into_iter().map(|a| a.address).collect::>(); accounts.into_iter() .filter(|a| !existing_accounts.contains(&a.address)) .map(|a| { let address = a.address.clone(); - try!(dst.insert(a)); + dst.insert(a)?; Ok(address) }).collect() } @@ -55,15 +55,15 @@ pub fn import_geth_accounts(dst: &KeyDirectory, desired: HashSet

, testn }; let src = GethDirectory::open(t); - let accounts = try!(src.load()); - let existing_accounts = try!(dst.load()).into_iter().map(|a| a.address).collect::>(); + let accounts = src.load()?; + let existing_accounts = dst.load()?.into_iter().map(|a| a.address).collect::>(); accounts.into_iter() .filter(|a| !existing_accounts.contains(&a.address)) .filter(|a| desired.contains(&a.address)) .map(|a| { let address = a.address.clone(); - try!(dst.insert(a)); + dst.insert(a)?; Ok(address) }).collect() } diff --git a/ethstore/src/json/bytes.rs b/ethstore/src/json/bytes.rs index fd4a3b995..5745c2cea 100644 --- a/ethstore/src/json/bytes.rs +++ b/ethstore/src/json/bytes.rs @@ -17,8 +17,8 @@ impl Deserialize for Bytes { fn deserialize(deserializer: &mut D) -> Result where D: Deserializer { - let s = try!(String::deserialize(deserializer)); - let data = try!(s.from_hex().map_err(|e| Error::custom(format!("Invalid hex value {}", e)))); + let s = String::deserialize(deserializer)?; + let data = s.from_hex().map_err(|e| Error::custom(format!("Invalid hex value {}", e)))?; Ok(Bytes(data)) } } diff --git a/ethstore/src/json/crypto.rs b/ethstore/src/json/crypto.rs index 99ef026b3..2ce728146 100644 --- a/ethstore/src/json/crypto.rs +++ b/ethstore/src/json/crypto.rs @@ -90,13 +90,13 @@ impl Visitor for CryptoVisitor { let mut mac = None; loop { - match try!(visitor.visit_key()) { - Some(CryptoField::Cipher) => { cipher = Some(try!(visitor.visit_value())); } - Some(CryptoField::CipherParams) => { cipherparams = Some(try!(visitor.visit_value())); } - Some(CryptoField::CipherText) => { ciphertext = Some(try!(visitor.visit_value())); } - Some(CryptoField::Kdf) => { kdf = Some(try!(visitor.visit_value())); } - Some(CryptoField::KdfParams) => { kdfparams = Some(try!(visitor.visit_value())); } - Some(CryptoField::Mac) => { mac = Some(try!(visitor.visit_value())); } + match visitor.visit_key()? { + Some(CryptoField::Cipher) => { cipher = Some(visitor.visit_value()?); } + Some(CryptoField::CipherParams) => { cipherparams = Some(visitor.visit_value()?); } + Some(CryptoField::CipherText) => { ciphertext = Some(visitor.visit_value()?); } + Some(CryptoField::Kdf) => { kdf = Some(visitor.visit_value()?); } + Some(CryptoField::KdfParams) => { kdfparams = Some(visitor.visit_value()?); } + Some(CryptoField::Mac) => { mac = Some(visitor.visit_value()?); } None => { break; } } } @@ -109,7 +109,7 @@ impl Visitor for CryptoVisitor { let ciphertext = match ciphertext { Some(ciphertext) => ciphertext, - None => try!(visitor.missing_field("ciphertext")), + None => visitor.missing_field("ciphertext")?, }; let kdf = match (kdf, kdfparams) { @@ -122,10 +122,10 @@ impl Visitor for CryptoVisitor { let mac = match mac { Some(mac) => mac, - None => try!(visitor.missing_field("mac")), + None => visitor.missing_field("mac")?, }; - try!(visitor.end()); + visitor.end()?; let result = Crypto { cipher: cipher, @@ -142,26 +142,26 @@ impl Serialize for Crypto { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer { - let mut state = try!(serializer.serialize_struct("Crypto", 6)); + let mut state = serializer.serialize_struct("Crypto", 6)?; match self.cipher { Cipher::Aes128Ctr(ref params) => { - try!(serializer.serialize_struct_elt(&mut state, "cipher", &CipherSer::Aes128Ctr)); - try!(serializer.serialize_struct_elt(&mut state, "cipherparams", params)); + serializer.serialize_struct_elt(&mut state, "cipher", &CipherSer::Aes128Ctr)?; + serializer.serialize_struct_elt(&mut state, "cipherparams", params)?; }, } - try!(serializer.serialize_struct_elt(&mut state, "ciphertext", &self.ciphertext)); + serializer.serialize_struct_elt(&mut state, "ciphertext", &self.ciphertext)?; match self.kdf { Kdf::Pbkdf2(ref params) => { - try!(serializer.serialize_struct_elt(&mut state, "kdf", &KdfSer::Pbkdf2)); - try!(serializer.serialize_struct_elt(&mut state, "kdfparams", params)); + serializer.serialize_struct_elt(&mut state, "kdf", &KdfSer::Pbkdf2)?; + serializer.serialize_struct_elt(&mut state, "kdfparams", params)?; }, Kdf::Scrypt(ref params) => { - try!(serializer.serialize_struct_elt(&mut state, "kdf", &KdfSer::Scrypt)); - try!(serializer.serialize_struct_elt(&mut state, "kdfparams", params)); + serializer.serialize_struct_elt(&mut state, "kdf", &KdfSer::Scrypt)?; + serializer.serialize_struct_elt(&mut state, "kdfparams", params)?; }, } - try!(serializer.serialize_struct_elt(&mut state, "mac", &self.mac)); + serializer.serialize_struct_elt(&mut state, "mac", &self.mac)?; serializer.serialize_struct_end(state) } } diff --git a/ethstore/src/json/id.rs b/ethstore/src/json/id.rs index cf098c83f..441fbc8c1 100644 --- a/ethstore/src/json/id.rs +++ b/ethstore/src/json/id.rs @@ -62,7 +62,7 @@ impl fmt::Display for Uuid { } fn copy_into(from: &str, into: &mut [u8]) -> Result<(), Error> { - let from = try!(from.from_hex().map_err(|_| Error::InvalidUuid)); + let from = from.from_hex().map_err(|_| Error::InvalidUuid)?; if from.len() != into.len() { return Err(Error::InvalidUuid); @@ -84,11 +84,11 @@ impl str::FromStr for Uuid { let mut uuid = [0u8; 16]; - try!(copy_into(parts[0], &mut uuid[0..4])); - try!(copy_into(parts[1], &mut uuid[4..6])); - try!(copy_into(parts[2], &mut uuid[6..8])); - try!(copy_into(parts[3], &mut uuid[8..10])); - try!(copy_into(parts[4], &mut uuid[10..16])); + copy_into(parts[0], &mut uuid[0..4])?; + copy_into(parts[1], &mut uuid[4..6])?; + copy_into(parts[2], &mut uuid[6..8])?; + copy_into(parts[3], &mut uuid[8..10])?; + copy_into(parts[4], &mut uuid[10..16])?; Ok(Uuid(uuid)) } diff --git a/ethstore/src/json/kdf.rs b/ethstore/src/json/kdf.rs index af751ad33..c9028f7cc 100644 --- a/ethstore/src/json/kdf.rs +++ b/ethstore/src/json/kdf.rs @@ -134,7 +134,7 @@ impl Serialize for KdfSerParams { impl Deserialize for KdfSerParams { fn deserialize(deserializer: &mut D) -> Result where D: Deserializer { - let v = try!(Value::deserialize(deserializer)); + let v = Value::deserialize(deserializer)?; Deserialize::deserialize(&mut value::Deserializer::new(v.clone())).map(KdfSerParams::Pbkdf2) .or_else(|_| Deserialize::deserialize(&mut value::Deserializer::new(v)).map(KdfSerParams::Scrypt)) diff --git a/ethstore/src/json/key_file.rs b/ethstore/src/json/key_file.rs index 323086fa0..fc9b442d5 100644 --- a/ethstore/src/json/key_file.rs +++ b/ethstore/src/json/key_file.rs @@ -93,11 +93,11 @@ impl Visitor for KeyFileVisitor { let mut meta = None; loop { - match try!(visitor.visit_key()) { - Some(KeyFileField::Id) => { id = Some(try!(visitor.visit_value())); } - Some(KeyFileField::Version) => { version = Some(try!(visitor.visit_value())); } - Some(KeyFileField::Crypto) => { crypto = Some(try!(visitor.visit_value())); } - Some(KeyFileField::Address) => { address = Some(try!(visitor.visit_value())); } + match visitor.visit_key()? { + Some(KeyFileField::Id) => { id = Some(visitor.visit_value()?); } + Some(KeyFileField::Version) => { version = Some(visitor.visit_value()?); } + Some(KeyFileField::Crypto) => { crypto = Some(visitor.visit_value()?); } + Some(KeyFileField::Address) => { address = Some(visitor.visit_value()?); } Some(KeyFileField::Name) => { name = visitor.visit_value().ok(); } // ignore anyhing that is not a string to be permissive. Some(KeyFileField::Meta) => { meta = visitor.visit_value().ok(); } // ignore anyhing that is not a string to be permissive. None => { break; } @@ -106,25 +106,25 @@ impl Visitor for KeyFileVisitor { let id = match id { Some(id) => id, - None => try!(visitor.missing_field("id")), + None => visitor.missing_field("id")?, }; let version = match version { Some(version) => version, - None => try!(visitor.missing_field("version")), + None => visitor.missing_field("version")?, }; let crypto = match crypto { Some(crypto) => crypto, - None => try!(visitor.missing_field("crypto")), + None => visitor.missing_field("crypto")?, }; let address = match address { Some(address) => address, - None => try!(visitor.missing_field("address")), + None => visitor.missing_field("address")?, }; - try!(visitor.end()); + visitor.end()?; let result = KeyFile { id: id, diff --git a/ethstore/src/presale.rs b/ethstore/src/presale.rs index ff3bde6f4..b9a15aed5 100644 --- a/ethstore/src/presale.rs +++ b/ethstore/src/presale.rs @@ -32,9 +32,9 @@ impl From for PresaleWallet { impl PresaleWallet { pub fn open

(path: P) -> Result where P: AsRef { - let file = try!(fs::File::open(path)); - let presale = try!(json::PresaleWallet::load(file) - .map_err(|e| Error::InvalidKeyFile(format!("{}", e)))); + let file = fs::File::open(path)?; + let presale = json::PresaleWallet::load(file) + .map_err(|e| Error::InvalidKeyFile(format!("{}", e)))?; Ok(PresaleWallet::from(presale)) } @@ -44,7 +44,7 @@ impl PresaleWallet { pbkdf2(&mut h_mac, password.as_bytes(), 2000, &mut derived_key); let mut key = vec![0; self.ciphertext.len()]; - let len = try!(crypto::aes::decrypt_cbc(&derived_key, &self.iv, &self.ciphertext, &mut key).map_err(|_| Error::InvalidPassword)); + let len = crypto::aes::decrypt_cbc(&derived_key, &self.iv, &self.ciphertext, &mut key).map_err(|_| Error::InvalidPassword)?; let unpadded = &key[..len]; let secret = Secret::from(unpadded.keccak256()); diff --git a/ethstore/tests/util/transient_dir.rs b/ethstore/tests/util/transient_dir.rs index 6a22a602d..a036f3c87 100644 --- a/ethstore/tests/util/transient_dir.rs +++ b/ethstore/tests/util/transient_dir.rs @@ -36,7 +36,7 @@ impl TransientDir { pub fn create() -> Result { let path = random_dir(); let result = TransientDir { - dir: try!(DiskDirectory::create(&path)), + dir: DiskDirectory::create(&path)?, path: path, }; diff --git a/evmbin/src/main.rs b/evmbin/src/main.rs index 8a08bd163..743b517ec 100644 --- a/evmbin/src/main.rs +++ b/evmbin/src/main.rs @@ -104,9 +104,9 @@ pub struct Success { } impl fmt::Display for Success { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { - try!(writeln!(f, "Gas used: {:?}", self.gas_used)); - try!(writeln!(f, "Output: {:?}", self.output)); - try!(writeln!(f, "Time: {}.{:.9}s", self.time.as_secs(), self.time.subsec_nanos())); + writeln!(f, "Gas used: {:?}", self.gas_used)?; + writeln!(f, "Output: {:?}", self.output)?; + writeln!(f, "Time: {}.{:.9}s", self.time.as_secs(), self.time.subsec_nanos())?; Ok(()) } } @@ -120,8 +120,8 @@ pub struct Failure { } impl fmt::Display for Failure { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { - try!(writeln!(f, "Error: {:?}", self.error)); - try!(writeln!(f, "Time: {}.{:.9}s", self.time.as_secs(), self.time.subsec_nanos())); + writeln!(f, "Error: {:?}", self.error)?; + writeln!(f, "Time: {}.{:.9}s", self.time.as_secs(), self.time.subsec_nanos())?; Ok(()) } } diff --git a/hash-fetch/src/client.rs b/hash-fetch/src/client.rs index bc173e80d..dd6d26033 100644 --- a/hash-fetch/src/client.rs +++ b/hash-fetch/src/client.rs @@ -114,16 +114,16 @@ impl HashFetch for Client { Ok(url) => { let future = self.fetch.fetch(&url).then(move |result| { fn validate_hash(path: PathBuf, hash: H256, result: Result) -> Result { - let response = try!(result); + let response = result?; // Read the response let mut reader = io::BufReader::new(response); - let mut writer = io::BufWriter::new(try!(fs::File::create(&path))); - try!(io::copy(&mut reader, &mut writer)); - try!(writer.flush()); + let mut writer = io::BufWriter::new(fs::File::create(&path)?); + io::copy(&mut reader, &mut writer)?; + writer.flush()?; // And validate the hash - let mut file_reader = io::BufReader::new(try!(fs::File::open(&path))); - let content_hash = try!(sha3(&mut file_reader)); + let mut file_reader = io::BufReader::new(fs::File::open(&path)?); + let content_hash = sha3(&mut file_reader)?; if content_hash != hash { Err(Error::HashMismatch{ got: content_hash, expected: hash }) } else { diff --git a/hash-fetch/src/urlhint.rs b/hash-fetch/src/urlhint.rs index 0b7b4fa4f..98f680ff2 100644 --- a/hash-fetch/src/urlhint.rs +++ b/hash-fetch/src/urlhint.rs @@ -119,12 +119,12 @@ impl URLHintContract { fn urlhint_address(&self) -> Option

{ let res = || { - let get_address = try!(self.registrar.function("getAddress".into()).map_err(as_string)); - let params = try!(get_address.encode_call( + let get_address = self.registrar.function("getAddress".into()).map_err(as_string)?; + let params = get_address.encode_call( vec![Token::FixedBytes((*"githubhint".sha3()).to_vec()), Token::String("A".into())] - ).map_err(as_string)); - let output = try!(self.client.call(try!(self.client.registrar()), params)); - let result = try!(get_address.decode_output(output).map_err(as_string)); + ).map_err(as_string)?; + let output = self.client.call(self.client.registrar()?, params)?; + let result = get_address.decode_output(output).map_err(as_string)?; match result.get(0) { Some(&Token::Address(address)) if address != *Address::default() => Ok(address.into()), diff --git a/ipc/codegen/src/lib.rs b/ipc/codegen/src/lib.rs index b4825d7f9..5ba51ab7b 100644 --- a/ipc/codegen/src/lib.rs +++ b/ipc/codegen/src/lib.rs @@ -162,7 +162,7 @@ fn cleanup(src_path: &str, attr: AttributeKind) -> Result<(), Error> { use std::path::{Path, PathBuf}; let out_dir = env::var_os("OUT_DIR").unwrap(); - let file_name = try!(PathBuf::from(src_path).file_name().ok_or(Error::InvalidFileName).map(|val| val.to_str().unwrap().to_owned())); + let file_name = PathBuf::from(src_path).file_name().ok_or(Error::InvalidFileName).map(|val| val.to_str().unwrap().to_owned())?; let mut registry = syntex::Registry::new(); match attr { @@ -183,7 +183,7 @@ pub fn derive_ipc(src_path: &str) -> Result<(), Error> { use std::path::{Path, PathBuf}; let out_dir = env::var_os("OUT_DIR").unwrap(); - let file_name = try!(PathBuf::from(src_path).file_name().ok_or(Error::InvalidFileName).map(|val| val.to_str().unwrap().to_owned())); + let file_name = PathBuf::from(src_path).file_name().ok_or(Error::InvalidFileName).map(|val| val.to_str().unwrap().to_owned())?; let final_path = Path::new(&out_dir).join(&file_name); @@ -217,7 +217,7 @@ pub fn derive_binary(src_path: &str) -> Result<(), Error> { use std::path::{Path, PathBuf}; let out_dir = env::var_os("OUT_DIR").unwrap(); - let file_name = try!(PathBuf::from(src_path).file_name().ok_or(Error::InvalidFileName).map(|val| val.to_str().unwrap().to_owned())); + let file_name = PathBuf::from(src_path).file_name().ok_or(Error::InvalidFileName).map(|val| val.to_str().unwrap().to_owned())?; let final_path = Path::new(&out_dir).join(&file_name); let mut registry = syntex::Registry::new(); diff --git a/ipc/codegen/src/serialization.rs b/ipc/codegen/src/serialization.rs index ed5b490c3..4d6e19295 100644 --- a/ipc/codegen/src/serialization.rs +++ b/ipc/codegen/src/serialization.rs @@ -388,8 +388,7 @@ fn binary_expr_enum( span: Span, enum_def: &ast::EnumDef, ) -> Result { - let arms: Vec<_> = try!( - enum_def.variants.iter() + let arms: Vec<_> = try!(enum_def.variants.iter() .enumerate() .map(|(variant_index, variant)| { binary_expr_variant( @@ -403,8 +402,7 @@ fn binary_expr_enum( variant_index, ) }) - .collect() - ); + .collect()); let (size_arms, write_arms, mut read_arms) = ( arms.iter().map(|x| x.size.clone()).collect::>(), diff --git a/ipc/nano/src/lib.rs b/ipc/nano/src/lib.rs index ce40183e9..8334dbf47 100644 --- a/ipc/nano/src/lib.rs +++ b/ipc/nano/src/lib.rs @@ -65,17 +65,17 @@ impl Deref for GuardedSocket where S: WithSocket { /// creates socket and connects endpoint to it /// for duplex (paired) connections with the service pub fn init_duplex_client(socket_addr: &str) -> Result, SocketError> where S: WithSocket { - let mut socket = try!(Socket::new(Protocol::Pair).map_err(|e| { + let mut socket = Socket::new(Protocol::Pair).map_err(|e| { warn!(target: "ipc", "Failed to create ipc socket: {:?}", e); SocketError::DuplexLink - })); + })?; socket.set_receive_timeout(DEFAULT_CONNECTION_TIMEOUT).unwrap(); - let endpoint = try!(socket.connect(socket_addr).map_err(|e| { + let endpoint = socket.connect(socket_addr).map_err(|e| { warn!(target: "ipc", "Failed to bind socket to address '{}': {:?}", socket_addr, e); SocketError::DuplexLink - })); + })?; Ok(GuardedSocket { client: Arc::new(S::init(socket)), @@ -87,19 +87,19 @@ pub fn init_duplex_client(socket_addr: &str) -> Result, Sock /// creates socket and connects endpoint to it /// for request-reply connections to the service pub fn client(socket_addr: &str, receive_timeout: Option) -> Result, SocketError> where S: WithSocket { - let mut socket = try!(Socket::new(Protocol::Req).map_err(|e| { + let mut socket = Socket::new(Protocol::Req).map_err(|e| { warn!(target: "ipc", "Failed to create ipc socket: {:?}", e); SocketError::RequestLink - })); + })?; if let Some(timeout) = receive_timeout { socket.set_receive_timeout(timeout).unwrap(); } - let endpoint = try!(socket.connect(socket_addr).map_err(|e| { + let endpoint = socket.connect(socket_addr).map_err(|e| { warn!(target: "ipc", "Failed to bind socket to address '{}': {:?}", socket_addr, e); SocketError::RequestLink - })); + })?; trace!(target: "ipc", "Created client for {}", socket_addr); Ok(GuardedSocket { @@ -210,15 +210,15 @@ impl Worker where S: IpcInterface { /// Add exclusive socket for paired client /// Only one connection over this address is allowed pub fn add_duplex(&mut self, addr: &str) -> Result<(), SocketError> { - let mut socket = try!(Socket::new(Protocol::Pair).map_err(|e| { + let mut socket = Socket::new(Protocol::Pair).map_err(|e| { warn!(target: "ipc", "Failed to create ipc socket: {:?}", e); SocketError::DuplexLink - })); + })?; - let endpoint = try!(socket.bind(addr).map_err(|e| { + let endpoint = socket.bind(addr).map_err(|e| { warn!(target: "ipc", "Failed to bind socket to address '{}': {:?}", addr, e); SocketError::DuplexLink - })); + })?; self.sockets.push((socket, endpoint)); @@ -232,16 +232,16 @@ impl Worker where S: IpcInterface { /// Add generic socket for request-reply style communications /// with multiple clients pub fn add_reqrep(&mut self, addr: &str) -> Result<(), SocketError> { - let mut socket = try!(Socket::new(Protocol::Rep).map_err(|e| { + let mut socket = Socket::new(Protocol::Rep).map_err(|e| { warn!(target: "ipc", "Failed to create ipc socket: {:?}", e); SocketError::DuplexLink - })); + })?; - let endpoint = try!(socket.bind(addr).map_err(|e| { + let endpoint = socket.bind(addr).map_err(|e| { warn!(target: "ipc", "Failed to bind socket to address '{}': {:?}", addr, e); SocketError::DuplexLink - })); + })?; self.sockets.push((socket, endpoint)); diff --git a/ipc/rpc/src/binary.rs b/ipc/rpc/src/binary.rs index eed894fce..f343fe7af 100644 --- a/ipc/rpc/src/binary.rs +++ b/ipc/rpc/src/binary.rs @@ -121,7 +121,7 @@ impl BinaryConvertable for Option where T: BinaryConvertable { fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result { if buffer.len() == 0 { return Self::from_empty_bytes(); } - Ok(Some(try!(T::from_bytes(buffer, length_stack)))) + Ok(Some(T::from_bytes(buffer, length_stack)?)) } fn from_empty_bytes() -> Result { @@ -144,12 +144,12 @@ impl BinaryConvertable for Result<(), E> { fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque) -> Result<(), BinaryConvertError> { match *self { Ok(_) => Err(BinaryConvertError::empty()), - Err(ref e) => Ok(try!(e.to_bytes(buffer, length_stack))), + Err(ref e) => Ok(e.to_bytes(buffer, length_stack)?), } } fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result { - Ok(Err(try!(E::from_bytes(&buffer, length_stack)))) + Ok(Err(E::from_bytes(&buffer, length_stack)?)) } fn from_empty_bytes() -> Result { @@ -172,13 +172,13 @@ impl BinaryConvertable for Result { fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque) -> Result<(), BinaryConvertError> { match *self { - Ok(ref r) => Ok(try!(r.to_bytes(buffer, length_stack))), + Ok(ref r) => Ok(r.to_bytes(buffer, length_stack)?), Err(_) => Err(BinaryConvertError::empty()), } } fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result { - Ok(Ok(try!(R::from_bytes(&buffer, length_stack)))) + Ok(Ok(R::from_bytes(&buffer, length_stack)?)) } fn from_empty_bytes() -> Result { @@ -203,14 +203,14 @@ impl BinaryConvertable for Result { buffer[0] = 0; if r.size() > 0 { - Ok(try!(r.to_bytes(&mut buffer[1..], length_stack))) + Ok(r.to_bytes(&mut buffer[1..], length_stack)?) } else { Ok(()) } }, Err(ref e) => { buffer[0] = 1; if e.size() > 0 { - Ok(try!(e.to_bytes(&mut buffer[1..], length_stack))) + Ok(e.to_bytes(&mut buffer[1..], length_stack)?) } else { Ok(()) } }, @@ -221,11 +221,11 @@ impl BinaryConvertable for Result { match buffer.len() { - 1 => Ok(Ok(try!(R::from_empty_bytes()))), - _ => Ok(Ok(try!(R::from_bytes(&buffer[1..], length_stack)))), + 1 => Ok(Ok(R::from_empty_bytes()?)), + _ => Ok(Ok(R::from_bytes(&buffer[1..], length_stack)?)), } } - 1 => Ok(Err(try!(E::from_bytes(&buffer[1..], length_stack)))), + 1 => Ok(Err(E::from_bytes(&buffer[1..], length_stack)?)), _ => Err(BinaryConvertError::variant(buffer[0])) } } @@ -260,13 +260,13 @@ impl BinaryConvertable for BTreeMap where K : BinaryConvertable + Or if key_size > 0 { let item_end = offset + key_size; - try!(key.to_bytes(&mut buffer[offset..item_end], length_stack)); + key.to_bytes(&mut buffer[offset..item_end], length_stack)?; offset = item_end; } if val_size > 0 { let item_end = offset + key_size; - try!(val.to_bytes(&mut buffer[offset..item_end], length_stack)); + val.to_bytes(&mut buffer[offset..item_end], length_stack)?; offset = item_end; } } @@ -282,29 +282,29 @@ impl BinaryConvertable for BTreeMap where K : BinaryConvertable + Or loop { let key_size = match K::len_params() { 0 => mem::size_of::(), - _ => try!(length_stack.pop_front().ok_or(BinaryConvertError::length())), + _ => length_stack.pop_front().ok_or(BinaryConvertError::length())?, }; let key = if key_size == 0 { - try!(K::from_empty_bytes()) + K::from_empty_bytes()? } else { if index + key_size > buffer.len() { return Err(BinaryConvertError::boundaries()) } - try!(K::from_bytes(&buffer[index..index+key_size], length_stack)) + K::from_bytes(&buffer[index..index+key_size], length_stack)? }; index = index + key_size; let val_size = match V::len_params() { 0 => mem::size_of::(), - _ => try!(length_stack.pop_front().ok_or(BinaryConvertError::length())), + _ => length_stack.pop_front().ok_or(BinaryConvertError::length())?, }; let val = if val_size == 0 { - try!(V::from_empty_bytes()) + V::from_empty_bytes()? } else { if index + val_size > buffer.len() { return Err(BinaryConvertError::boundaries()) } - try!(V::from_bytes(&buffer[index..index+val_size], length_stack)) + V::from_bytes(&buffer[index..index+val_size], length_stack)? }; result.insert(key, val); index = index + val_size; @@ -344,7 +344,7 @@ impl BinaryConvertable for VecDeque where T: BinaryConvertable { }; if next_size > 0 { let item_end = offset + next_size; - try!(item.to_bytes(&mut buffer[offset..item_end], length_stack)); + item.to_bytes(&mut buffer[offset..item_end], length_stack)?; offset = item_end; } } @@ -364,16 +364,16 @@ impl BinaryConvertable for VecDeque where T: BinaryConvertable { loop { let next_size = match T::len_params() { 0 => mem::size_of::(), - _ => try!(length_stack.pop_front().ok_or(BinaryConvertError::length())), + _ => length_stack.pop_front().ok_or(BinaryConvertError::length())?, }; let item = if next_size == 0 { - try!(T::from_empty_bytes()) + T::from_empty_bytes()? } else { if index + next_size > buffer.len() { return Err(BinaryConvertError::boundaries()) } - try!(T::from_bytes(&buffer[index..index+next_size], length_stack)) + T::from_bytes(&buffer[index..index+next_size], length_stack)? }; result.push_back(item); @@ -413,7 +413,7 @@ impl BinaryConvertable for Vec where T: BinaryConvertable { }; if next_size > 0 { let item_end = offset + next_size; - try!(item.to_bytes(&mut buffer[offset..item_end], length_stack)); + item.to_bytes(&mut buffer[offset..item_end], length_stack)?; offset = item_end; } } @@ -433,16 +433,16 @@ impl BinaryConvertable for Vec where T: BinaryConvertable { loop { let next_size = match T::len_params() { 0 => mem::size_of::(), - _ => try!(length_stack.pop_front().ok_or(BinaryConvertError::length())), + _ => length_stack.pop_front().ok_or(BinaryConvertError::length())?, }; let item = if next_size == 0 { - try!(T::from_empty_bytes()) + T::from_empty_bytes()? } else { if index + next_size > buffer.len() { return Err(BinaryConvertError::boundaries()) } - try!(T::from_bytes(&buffer[index..index+next_size], length_stack)) + T::from_bytes(&buffer[index..index+next_size], length_stack)? }; result.push(item); @@ -498,13 +498,13 @@ impl BinaryConvertable for Range where T: BinaryConvertable { } fn to_bytes(&self, buffer: &mut[u8], length_stack: &mut VecDeque) -> Result<(), BinaryConvertError> { - try!(self.start.to_bytes(&mut buffer[..mem::size_of::()], length_stack)); - try!(self.end.to_bytes(&mut buffer[mem::size_of::() + 1..], length_stack)); + self.start.to_bytes(&mut buffer[..mem::size_of::()], length_stack)?; + self.end.to_bytes(&mut buffer[mem::size_of::() + 1..], length_stack)?; Ok(()) } fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result { - Ok(try!(T::from_bytes(&buffer[..mem::size_of::()], length_stack))..try!(T::from_bytes(&buffer[mem::size_of::()+1..], length_stack))) + Ok(T::from_bytes(&buffer[..mem::size_of::()], length_stack)?..T::from_bytes(&buffer[mem::size_of::()+1..], length_stack)?) } fn len_params() -> usize { @@ -519,15 +519,15 @@ impl BinaryConvertable for ::std::cell::RefCell where T: BinaryConvertable } fn from_empty_bytes() -> Result { - Ok(::std::cell::RefCell::new(try!(T::from_empty_bytes()))) + Ok(::std::cell::RefCell::new(T::from_empty_bytes()?)) } fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result { - Ok(::std::cell::RefCell::new(try!(T::from_bytes(buffer, length_stack)))) + Ok(::std::cell::RefCell::new(T::from_bytes(buffer, length_stack)?)) } fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque) -> Result<(), BinaryConvertError> { - try!(self.borrow().to_bytes(buffer, length_stack)); + self.borrow().to_bytes(buffer, length_stack)?; Ok(()) } @@ -542,15 +542,15 @@ impl BinaryConvertable for ::std::cell::Cell where T: BinaryConvertable + } fn from_empty_bytes() -> Result { - Ok(::std::cell::Cell::new(try!(T::from_empty_bytes()))) + Ok(::std::cell::Cell::new(T::from_empty_bytes()?)) } fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result { - Ok(::std::cell::Cell::new(try!(T::from_bytes(buffer, length_stack)))) + Ok(::std::cell::Cell::new(T::from_bytes(buffer, length_stack)?)) } fn to_bytes(&self, buffer: &mut [u8], length_stack: &mut VecDeque) -> Result<(), BinaryConvertError> { - try!(self.get().to_bytes(buffer, length_stack)); + self.get().to_bytes(buffer, length_stack)?; Ok(()) } @@ -596,34 +596,33 @@ pub fn deserialize_from(r: &mut R) -> Result let fixed_size = mem::size_of::(); let mut payload_buffer = Vec::with_capacity(fixed_size); unsafe { payload_buffer.set_len(fixed_size); } - let bytes_read = try!(r.read(&mut payload_buffer)); + let bytes_read = r.read(&mut payload_buffer)?; if bytes_read != mem::size_of::() { return Err(BinaryError::Serialization(BinaryConvertError::size(fixed_size, bytes_read))) } - Ok(try!(T::from_bytes(&payload_buffer[..], &mut fake_stack))) + Ok(T::from_bytes(&payload_buffer[..], &mut fake_stack)?) }, _ => { let mut payload = Vec::new(); - try!(r.read_to_end(&mut payload)); + r.read_to_end(&mut payload)?; - let stack_len = try!(u64::from_bytes(&payload[0..8], &mut fake_stack)) as usize; + let stack_len = u64::from_bytes(&payload[0..8], &mut fake_stack)? as usize; let mut length_stack = VecDeque::::with_capacity(stack_len); if stack_len > 0 { for idx in 0..stack_len { - let stack_item = try!(u64::from_bytes(&payload[8 + idx*8..8 + (idx+1)*8], &mut fake_stack)); + let stack_item = u64::from_bytes(&payload[8 + idx*8..8 + (idx+1)*8], &mut fake_stack)?; length_stack.push_back(stack_item as usize); } } - //try!(r.read(&mut size_buffer).map_err(|_| BinaryConvertError)); - let size = try!(u64::from_bytes(&payload[8+stack_len*8..16+stack_len*8], &mut fake_stack)) as usize; + let size = u64::from_bytes(&payload[8+stack_len*8..16+stack_len*8], &mut fake_stack)? as usize; match size { 0 => { - Ok(try!(T::from_empty_bytes())) + Ok(T::from_empty_bytes()?) }, _ => { - Ok(try!(T::from_bytes(&payload[16+stack_len*8..], &mut length_stack))) + Ok(T::from_bytes(&payload[16+stack_len*8..], &mut length_stack)?) } } }, @@ -647,8 +646,8 @@ pub fn serialize_into(t: &T, w: &mut W) -> Result<(), BinaryError> let fixed_size = mem::size_of::(); let mut buffer = Vec::with_capacity(fixed_size); unsafe { buffer.set_len(fixed_size); } - try!(t.to_bytes(&mut buffer[..], &mut fake_stack)); - try!(w.write(&buffer[..])); + t.to_bytes(&mut buffer[..], &mut fake_stack)?; + w.write(&buffer[..])?; Ok(()) }, _ => { @@ -657,37 +656,37 @@ pub fn serialize_into(t: &T, w: &mut W) -> Result<(), BinaryError> let size = t.size(); if size == 0 { - try!(w.write(&size_buffer)); - try!(w.write(&size_buffer)); + w.write(&size_buffer)?; + w.write(&size_buffer)?; return Ok(()); } let mut buffer = Vec::with_capacity(size); unsafe { buffer.set_len(size); } - try!(t.to_bytes(&mut buffer[..], &mut length_stack)); + t.to_bytes(&mut buffer[..], &mut length_stack)?; let stack_len = length_stack.len(); - try!((stack_len as u64).to_bytes(&mut size_buffer[..], &mut fake_stack)); - try!(w.write(&size_buffer[..])); + (stack_len as u64).to_bytes(&mut size_buffer[..], &mut fake_stack)?; + w.write(&size_buffer[..])?; if stack_len > 0 { let mut header_buffer = Vec::with_capacity(stack_len * 8); unsafe { header_buffer.set_len(stack_len * 8); }; - try!((stack_len as u64).to_bytes(&mut header_buffer[0..8], &mut fake_stack)); + (stack_len as u64).to_bytes(&mut header_buffer[0..8], &mut fake_stack)?; let mut idx = 0; loop { match length_stack.pop_front() { - Some(val) => try!((val as u64).to_bytes(&mut header_buffer[idx * 8..(idx+1) * 8], &mut fake_stack)), + Some(val) => (val as u64).to_bytes(&mut header_buffer[idx * 8..(idx+1) * 8], &mut fake_stack)?, None => { break; } } idx = idx + 1; } - try!(w.write(&header_buffer[..])); + w.write(&header_buffer[..])?; } - try!((size as u64).to_bytes(&mut size_buffer[..], &mut fake_stack)); - try!(w.write(&size_buffer[..])); + (size as u64).to_bytes(&mut size_buffer[..], &mut fake_stack)?; + w.write(&size_buffer[..])?; - try!(w.write(&buffer[..])); + w.write(&buffer[..])?; Ok(()) }, @@ -697,7 +696,7 @@ pub fn serialize_into(t: &T, w: &mut W) -> Result<(), BinaryError> pub fn serialize(t: &T) -> Result, BinaryError> { use std::io::Cursor; let mut buff = Cursor::new(Vec::new()); - try!(serialize_into(t, &mut buff)); + serialize_into(t, &mut buff)?; let into_inner = buff.into_inner(); Ok(into_inner) } diff --git a/json/src/hash.rs b/json/src/hash.rs index b09c596f1..bfac72f15 100644 --- a/json/src/hash.rs +++ b/json/src/hash.rs @@ -54,12 +54,12 @@ macro_rules! impl_hash { let value = match value.len() { 0 => $inner::from(0), 2 if value == "0x" => $inner::from(0), - _ if value.starts_with("0x") => try!($inner::from_str(&value[2..]).map_err(|_| { + _ if value.starts_with("0x") => $inner::from_str(&value[2..]).map_err(|_| { Error::custom(format!("Invalid hex value {}.", value).as_str()) - })), - _ => try!($inner::from_str(value).map_err(|_| { + })?, + _ => $inner::from_str(value).map_err(|_| { Error::custom(format!("Invalid hex value {}.", value).as_str()) - })) + })?, }; Ok($name(value)) diff --git a/json/src/trie/input.rs b/json/src/trie/input.rs index b8cf3c26e..8be62b977 100644 --- a/json/src/trie/input.rs +++ b/json/src/trie/input.rs @@ -46,16 +46,16 @@ impl Visitor for InputVisitor { let mut result = BTreeMap::new(); loop { - let key_str: Option = try!(visitor.visit_key()); + let key_str: Option = visitor.visit_key()?; let key = match key_str { - Some(ref k) if k.starts_with("0x") => try!(Bytes::from_str(k).map_err(Error::custom)), + Some(ref k) if k.starts_with("0x") => Bytes::from_str(k).map_err(Error::custom)?, Some(k) => Bytes::new(k.into_bytes()), None => { break; } }; - let val_str: Option = try!(visitor.visit_value()); + let val_str: Option = visitor.visit_value()?; let val = match val_str { - Some(ref v) if v.starts_with("0x") => Some(try!(Bytes::from_str(v).map_err(Error::custom))), + Some(ref v) if v.starts_with("0x") => Some(Bytes::from_str(v).map_err(Error::custom)?), Some(v) => Some(Bytes::new(v.into_bytes())), None => None, }; @@ -63,7 +63,7 @@ impl Visitor for InputVisitor { result.insert(key, val); } - try!(visitor.end()); + visitor.end()?; let input = Input { data: result @@ -76,7 +76,7 @@ impl Visitor for InputVisitor { let mut result = BTreeMap::new(); loop { - let keyval: Option>> = try!(visitor.visit()); + let keyval: Option>> = visitor.visit()?; let keyval = match keyval { Some(k) => k, _ => { break; }, @@ -90,13 +90,13 @@ impl Visitor for InputVisitor { let ref val_str: Option = keyval[1]; let key = match *key_str { - Some(ref k) if k.starts_with("0x") => try!(Bytes::from_str(k).map_err(Error::custom)), + Some(ref k) if k.starts_with("0x") => Bytes::from_str(k).map_err(Error::custom)?, Some(ref k) => Bytes::new(k.clone().into_bytes()), None => { break; } }; let val = match *val_str { - Some(ref v) if v.starts_with("0x") => Some(try!(Bytes::from_str(v).map_err(Error::custom))), + Some(ref v) if v.starts_with("0x") => Some(Bytes::from_str(v).map_err(Error::custom)?), Some(ref v) => Some(Bytes::new(v.clone().into_bytes())), None => None, }; @@ -104,7 +104,7 @@ impl Visitor for InputVisitor { result.insert(key, val); } - try!(visitor.end()); + visitor.end()?; let input = Input { data: result diff --git a/json/src/uint.rs b/json/src/uint.rs index f444da326..e7c9261c3 100644 --- a/json/src/uint.rs +++ b/json/src/uint.rs @@ -69,12 +69,12 @@ impl Visitor for UintVisitor { let value = match value.len() { 0 => U256::from(0), 2 if value.starts_with("0x") => U256::from(0), - _ if value.starts_with("0x") => try!(U256::from_str(&value[2..]).map_err(|_| { + _ if value.starts_with("0x") => U256::from_str(&value[2..]).map_err(|_| { Error::custom(format!("Invalid hex value {}.", value).as_str()) - })), - _ => try!(U256::from_dec_str(value).map_err(|_| { + })?, + _ => U256::from_dec_str(value).map_err(|_| { Error::custom(format!("Invalid decimal value {}.", value).as_str()) - })) + })? }; Ok(Uint(value)) diff --git a/logger/src/lib.rs b/logger/src/lib.rs index 78b6edca4..25da942fa 100644 --- a/logger/src/lib.rs +++ b/logger/src/lib.rs @@ -86,10 +86,9 @@ pub fn setup_log(config: &Config) -> Result, String> { let mut open_options = fs::OpenOptions::new(); let maybe_file = match config.file.as_ref() { - Some(f) => Some(try!(open_options + Some(f) => Some(open_options .append(true).create(true).open(f) - .map_err(|_| format!("Cannot write to log file given: {}", f)) - )), + .map_err(|_| format!("Cannot write to log file given: {}", f))?), None => None, }; diff --git a/parity/account.rs b/parity/account.rs index 15e712413..cf70b0908 100644 --- a/parity/account.rs +++ b/parity/account.rs @@ -70,7 +70,7 @@ pub fn execute(cmd: AccountCmd) -> Result { } fn keys_dir(path: String, spec: SpecType) -> Result { - let spec = try!(spec.spec()); + let spec = spec.spec()?; let mut path = PathBuf::from(&path); path.push(spec.data_dir); DiskDirectory::create(path).map_err(|e| format!("Could not open keys directory: {}", e)) @@ -85,20 +85,20 @@ fn secret_store(dir: Box, iterations: Option) -> Result Result { let password: String = match n.password_file { - Some(file) => try!(password_from_file(file)), - None => try!(password_prompt()), + Some(file) => password_from_file(file)?, + None => password_prompt()?, }; - let dir = Box::new(try!(keys_dir(n.path, n.spec))); - let secret_store = Box::new(try!(secret_store(dir, Some(n.iterations)))); + let dir = Box::new(keys_dir(n.path, n.spec)?); + let secret_store = Box::new(secret_store(dir, Some(n.iterations))?); let acc_provider = AccountProvider::new(secret_store); - let new_account = try!(acc_provider.new_account(&password).map_err(|e| format!("Could not create new account: {}", e))); + let new_account = acc_provider.new_account(&password).map_err(|e| format!("Could not create new account: {}", e))?; Ok(format!("{:?}", new_account)) } fn list(list_cmd: ListAccounts) -> Result { - let dir = Box::new(try!(keys_dir(list_cmd.path, list_cmd.spec))); - let secret_store = Box::new(try!(secret_store(dir, None))); + let dir = Box::new(keys_dir(list_cmd.path, list_cmd.spec)?); + let secret_store = Box::new(secret_store(dir, None)?); let acc_provider = AccountProvider::new(secret_store); let accounts = acc_provider.accounts(); let result = accounts.into_iter() @@ -110,11 +110,11 @@ fn list(list_cmd: ListAccounts) -> Result { } fn import(i: ImportAccounts) -> Result { - let to = try!(keys_dir(i.to, i.spec)); + let to = keys_dir(i.to, i.spec)?; let mut imported = 0; for path in &i.from { let from = DiskDirectory::at(path); - imported += try!(import_accounts(&from, &to).map_err(|_| "Importing accounts failed.")).len(); + imported += import_accounts(&from, &to).map_err(|_| "Importing accounts failed.")?.len(); } Ok(format!("{} account(s) imported", imported)) } @@ -123,8 +123,8 @@ fn import_geth(i: ImportFromGethAccounts) -> Result { use std::io::ErrorKind; use ethcore::ethstore::Error; - let dir = Box::new(try!(keys_dir(i.to, i.spec))); - let secret_store = Box::new(try!(secret_store(dir, None))); + let dir = Box::new(keys_dir(i.to, i.spec)?); + let secret_store = Box::new(secret_store(dir, None)?); let geth_accounts = read_geth_accounts(i.testnet); match secret_store.import_geth_accounts(geth_accounts, i.testnet) { Ok(v) => Ok(format!("Successfully imported {} account(s) from geth.", v.len())), diff --git a/parity/blockchain.rs b/parity/blockchain.rs index 6521efc82..0b1af4706 100644 --- a/parity/blockchain.rs +++ b/parity/blockchain.rs @@ -149,7 +149,7 @@ fn execute_import(cmd: ImportBlockchain) -> Result<(), String> { let panic_handler = PanicHandler::new_in_arc(); // load spec file - let spec = try!(cmd.spec.spec()); + let spec = cmd.spec.spec()?; // load genesis hash let genesis_hash = spec.genesis_header().hash(); @@ -161,7 +161,7 @@ fn execute_import(cmd: ImportBlockchain) -> Result<(), String> { let user_defaults_path = db_dirs.user_defaults_path(); // load user defaults - let mut user_defaults = try!(UserDefaults::load(&user_defaults_path)); + let mut user_defaults = UserDefaults::load(&user_defaults_path)?; fdlimit::raise_fd_limit(); @@ -169,20 +169,20 @@ fn execute_import(cmd: ImportBlockchain) -> Result<(), String> { let algorithm = cmd.pruning.to_algorithm(&user_defaults); // check if tracing is on - let tracing = try!(tracing_switch_to_bool(cmd.tracing, &user_defaults)); + let tracing = tracing_switch_to_bool(cmd.tracing, &user_defaults)?; // check if fatdb is on - let fat_db = try!(fatdb_switch_to_bool(cmd.fat_db, &user_defaults, algorithm)); + let fat_db = fatdb_switch_to_bool(cmd.fat_db, &user_defaults, algorithm)?; // prepare client and snapshot paths. let client_path = db_dirs.client_path(algorithm); let snapshot_path = db_dirs.snapshot_path(); // execute upgrades - try!(execute_upgrades(&cmd.dirs.base, &db_dirs, algorithm, cmd.compaction.compaction_profile(db_dirs.db_root_path().as_path()))); + execute_upgrades(&cmd.dirs.base, &db_dirs, algorithm, cmd.compaction.compaction_profile(db_dirs.db_root_path().as_path()))?; // create dirs used by parity - try!(cmd.dirs.create_dirs(false, false)); + cmd.dirs.create_dirs(false, false)?; // prepare client config let mut client_config = to_client_config( @@ -202,14 +202,14 @@ fn execute_import(cmd: ImportBlockchain) -> Result<(), String> { client_config.queue.verifier_settings = cmd.verifier_settings; // build client - let service = try!(ClientService::start( + let service = ClientService::start( client_config, &spec, &client_path, &snapshot_path, &cmd.dirs.ipc_path(), Arc::new(Miner::with_spec(&spec)), - ).map_err(|e| format!("Client service error: {:?}", e))); + ).map_err(|e| format!("Client service error: {:?}", e))?; // free up the spec in memory. drop(spec); @@ -218,7 +218,7 @@ fn execute_import(cmd: ImportBlockchain) -> Result<(), String> { let client = service.client(); let mut instream: Box = match cmd.file_path { - Some(f) => Box::new(try!(fs::File::open(&f).map_err(|_| format!("Cannot open given file: {}", f)))), + Some(f) => Box::new(fs::File::open(&f).map_err(|_| format!("Cannot open given file: {}", f))?), None => Box::new(io::stdin()), }; @@ -230,7 +230,7 @@ fn execute_import(cmd: ImportBlockchain) -> Result<(), String> { let format = match cmd.format { Some(format) => format, None => { - first_read = try!(instream.read(&mut first_bytes).map_err(|_| "Error reading from the file/stream.")); + first_read = instream.read(&mut first_bytes).map_err(|_| "Error reading from the file/stream.")?; match first_bytes[0] { 0xf9 => DataFormat::Binary, _ => DataFormat::Hex, @@ -262,23 +262,23 @@ fn execute_import(cmd: ImportBlockchain) -> Result<(), String> { let n = if first_read > 0 { first_read } else { - try!(instream.read(&mut bytes).map_err(|_| "Error reading from the file/stream.")) + instream.read(&mut bytes).map_err(|_| "Error reading from the file/stream.")? }; if n == 0 { break; } first_read = 0; - let s = try!(PayloadInfo::from(&bytes).map_err(|e| format!("Invalid RLP in the file/stream: {:?}", e))).total(); + let s = PayloadInfo::from(&bytes).map_err(|e| format!("Invalid RLP in the file/stream: {:?}", e))?.total(); bytes.resize(s, 0); - try!(instream.read_exact(&mut bytes[n..]).map_err(|_| "Error reading from the file/stream.")); - try!(do_import(bytes)); + instream.read_exact(&mut bytes[n..]).map_err(|_| "Error reading from the file/stream.")?; + do_import(bytes)?; } } DataFormat::Hex => { for line in BufReader::new(instream).lines() { - let s = try!(line.map_err(|_| "Error reading from the file/stream.")); + let s = line.map_err(|_| "Error reading from the file/stream.")?; let s = if first_read > 0 {from_utf8(&first_bytes).unwrap().to_owned() + &(s[..])} else {s}; first_read = 0; - let bytes = try!(s.from_hex().map_err(|_| "Invalid hex in file/stream.")); - try!(do_import(bytes)); + let bytes = s.from_hex().map_err(|_| "Invalid hex in file/stream.")?; + do_import(bytes)?; } } } @@ -288,7 +288,7 @@ fn execute_import(cmd: ImportBlockchain) -> Result<(), String> { user_defaults.pruning = algorithm; user_defaults.tracing = tracing; user_defaults.fat_db = fat_db; - try!(user_defaults.save(&user_defaults_path)); + user_defaults.save(&user_defaults_path)?; let report = client.report(); @@ -318,7 +318,7 @@ fn start_client( ) -> Result { // load spec file - let spec = try!(spec.spec()); + let spec = spec.spec()?; // load genesis hash let genesis_hash = spec.genesis_header().hash(); @@ -330,7 +330,7 @@ fn start_client( let user_defaults_path = db_dirs.user_defaults_path(); // load user defaults - let user_defaults = try!(UserDefaults::load(&user_defaults_path)); + let user_defaults = UserDefaults::load(&user_defaults_path)?; fdlimit::raise_fd_limit(); @@ -338,32 +338,32 @@ fn start_client( let algorithm = pruning.to_algorithm(&user_defaults); // check if tracing is on - let tracing = try!(tracing_switch_to_bool(tracing, &user_defaults)); + let tracing = tracing_switch_to_bool(tracing, &user_defaults)?; // check if fatdb is on - let fat_db = try!(fatdb_switch_to_bool(fat_db, &user_defaults, algorithm)); + let fat_db = fatdb_switch_to_bool(fat_db, &user_defaults, algorithm)?; // prepare client and snapshot paths. let client_path = db_dirs.client_path(algorithm); let snapshot_path = db_dirs.snapshot_path(); // execute upgrades - try!(execute_upgrades(&dirs.base, &db_dirs, algorithm, compaction.compaction_profile(db_dirs.db_root_path().as_path()))); + execute_upgrades(&dirs.base, &db_dirs, algorithm, compaction.compaction_profile(db_dirs.db_root_path().as_path()))?; // create dirs used by parity - try!(dirs.create_dirs(false, false)); + dirs.create_dirs(false, false)?; // prepare client config let client_config = to_client_config(&cache_config, Mode::Active, tracing, fat_db, compaction, wal, VMType::default(), "".into(), algorithm, pruning_history, true); - let service = try!(ClientService::start( + let service = ClientService::start( client_config, &spec, &client_path, &snapshot_path, &dirs.ipc_path(), Arc::new(Miner::with_spec(&spec)), - ).map_err(|e| format!("Client service error: {:?}", e))); + ).map_err(|e| format!("Client service error: {:?}", e))?; drop(spec); Ok(service) @@ -371,7 +371,7 @@ fn start_client( fn execute_export(cmd: ExportBlockchain) -> Result<(), String> { // Setup panic handler - let service = try!(start_client(cmd.dirs, cmd.spec, cmd.pruning, cmd.pruning_history, cmd.tracing, cmd.fat_db, cmd.compaction, cmd.wal, cmd.cache_config)); + let service = start_client(cmd.dirs, cmd.spec, cmd.pruning, cmd.pruning_history, cmd.tracing, cmd.fat_db, cmd.compaction, cmd.wal, cmd.cache_config)?; let panic_handler = PanicHandler::new_in_arc(); let format = cmd.format.unwrap_or_default(); @@ -379,18 +379,18 @@ fn execute_export(cmd: ExportBlockchain) -> Result<(), String> { let client = service.client(); let mut out: Box = match cmd.file_path { - Some(f) => Box::new(try!(fs::File::create(&f).map_err(|_| format!("Cannot write to file given: {}", f)))), + Some(f) => Box::new(fs::File::create(&f).map_err(|_| format!("Cannot write to file given: {}", f))?), None => Box::new(io::stdout()), }; - let from = try!(client.block_number(cmd.from_block).ok_or("From block could not be found")); - let to = try!(client.block_number(cmd.to_block).ok_or("To block could not be found")); + let from = client.block_number(cmd.from_block).ok_or("From block could not be found")?; + let to = client.block_number(cmd.to_block).ok_or("To block could not be found")?; for i in from..(to + 1) { if i % 10000 == 0 { info!("#{}", i); } - let b = try!(client.block(BlockId::Number(i)).ok_or("Error exporting incomplete chain")); + let b = client.block(BlockId::Number(i)).ok_or("Error exporting incomplete chain")?; match format { DataFormat::Binary => { out.write(&b).expect("Couldn't write to stream."); } DataFormat::Hex => { out.write_fmt(format_args!("{}", b.pretty())).expect("Couldn't write to stream."); } @@ -403,14 +403,14 @@ fn execute_export(cmd: ExportBlockchain) -> Result<(), String> { fn execute_export_state(cmd: ExportState) -> Result<(), String> { // Setup panic handler - let service = try!(start_client(cmd.dirs, cmd.spec, cmd.pruning, cmd.pruning_history, cmd.tracing, cmd.fat_db, cmd.compaction, cmd.wal, cmd.cache_config)); + let service = start_client(cmd.dirs, cmd.spec, cmd.pruning, cmd.pruning_history, cmd.tracing, cmd.fat_db, cmd.compaction, cmd.wal, cmd.cache_config)?; let panic_handler = PanicHandler::new_in_arc(); panic_handler.forward_from(&service); let client = service.client(); let mut out: Box = match cmd.file_path { - Some(f) => Box::new(try!(fs::File::create(&f).map_err(|_| format!("Cannot write to file given: {}", f)))), + Some(f) => Box::new(fs::File::create(&f).map_err(|_| format!("Cannot write to file given: {}", f))?), None => Box::new(io::stdout()), }; @@ -420,7 +420,7 @@ fn execute_export_state(cmd: ExportState) -> Result<(), String> { out.write_fmt(format_args!("{{ \"state\": [", )).expect("Couldn't write to stream."); loop { - let accounts = try!(client.list_accounts(at, last.as_ref(), 1000).ok_or("Specified block not found")); + let accounts = client.list_accounts(at, last.as_ref(), 1000).ok_or("Specified block not found")?; if accounts.is_empty() { break; } @@ -450,7 +450,7 @@ fn execute_export_state(cmd: ExportState) -> Result<(), String> { out.write_fmt(format_args!(", \"storage\": {{")).expect("Write error"); let mut last_storage: Option = None; loop { - let keys = try!(client.list_storage(at, &account, last_storage.as_ref(), 1000).ok_or("Specified block not found")); + let keys = client.list_storage(at, &account, last_storage.as_ref(), 1000).ok_or("Specified block not found")?; if keys.is_empty() { break; } @@ -482,14 +482,14 @@ fn execute_export_state(cmd: ExportState) -> Result<(), String> { } pub fn kill_db(cmd: KillBlockchain) -> Result<(), String> { - let spec = try!(cmd.spec.spec()); + let spec = cmd.spec.spec()?; let genesis_hash = spec.genesis_header().hash(); let db_dirs = cmd.dirs.database(genesis_hash, None, spec.data_dir); let user_defaults_path = db_dirs.user_defaults_path(); - let user_defaults = try!(UserDefaults::load(&user_defaults_path)); + let user_defaults = UserDefaults::load(&user_defaults_path)?; let algorithm = cmd.pruning.to_algorithm(&user_defaults); let dir = db_dirs.db_path(algorithm); - try!(fs::remove_dir_all(&dir).map_err(|e| format!("Error removing database: {:?}", e))); + fs::remove_dir_all(&dir).map_err(|e| format!("Error removing database: {:?}", e))?; info!("Database deleted."); Ok(()) } diff --git a/parity/boot.rs b/parity/boot.rs index 30349284d..d0155c7dd 100644 --- a/parity/boot.rs +++ b/parity/boot.rs @@ -53,9 +53,7 @@ pub fn payload() -> Result { use std::io::Read; let mut buffer = Vec::new(); - try!( - io::stdin().read_to_end(&mut buffer).map_err(BootError::ReadArgs) - ); + io::stdin().read_to_end(&mut buffer).map_err(BootError::ReadArgs)?; ipc::binary::deserialize::(&buffer).map_err(BootError::DecodeArgs) } diff --git a/parity/cli/usage.rs b/parity/cli/usage.rs index 378ae8ce4..235087168 100644 --- a/parity/cli/usage.rs +++ b/parity/cli/usage.rs @@ -137,7 +137,7 @@ macro_rules! usage { impl Args { pub fn parse>(command: &[S]) -> Result { - let raw_args = try!(RawArgs::parse(command)); + let raw_args = RawArgs::parse(command)?; // Skip loading config file if no_config flag is specified if raw_args.flag_no_config { @@ -151,8 +151,8 @@ macro_rules! usage { (Ok(mut file), _) => { println_stderr!("Loading config file from {}", &config_file); let mut config = String::new(); - try!(file.read_to_string(&mut config).map_err(|e| ArgsError::Config(config_file, e))); - try!(Self::parse_config(&config)) + file.read_to_string(&mut config).map_err(|e| ArgsError::Config(config_file, e))?; + Self::parse_config(&config)? }, // Don't display error in case default config cannot be loaded. (Err(_), false) => Config::default(), @@ -172,7 +172,7 @@ macro_rules! usage { #[cfg(test)] fn parse_with_config>(command: &[S], config: Config) -> Result { - Ok(try!(RawArgs::parse(command)).into_args(config)) + RawArgs::parse(command).map(|raw| raw.into_args(config)).map_err(ArgsError::Docopt) } fn parse_config(config: &str) -> Result { diff --git a/parity/configuration.rs b/parity/configuration.rs index bb6556808..23adffe66 100644 --- a/parity/configuration.rs +++ b/parity/configuration.rs @@ -85,7 +85,7 @@ pub struct Configuration { impl Configuration { pub fn parse>(command: &[S]) -> Result { - let args = try!(Args::parse(command)); + let args = Args::parse(command)?; let config = Configuration { args: args, @@ -96,29 +96,29 @@ impl Configuration { pub fn into_command(self) -> Result { let dirs = self.directories(); - let pruning = try!(self.args.flag_pruning.parse()); + let pruning = self.args.flag_pruning.parse()?; let pruning_history = self.args.flag_pruning_history; - let vm_type = try!(self.vm_type()); - let mode = match self.args.flag_mode.as_ref() { "last" => None, mode => Some(try!(to_mode(&mode, self.args.flag_mode_timeout, self.args.flag_mode_alarm))), }; - let update_policy = try!(self.update_policy()); - let miner_options = try!(self.miner_options()); + let vm_type = self.vm_type()?; + let mode = match self.args.flag_mode.as_ref() { "last" => None, mode => Some(to_mode(&mode, self.args.flag_mode_timeout, self.args.flag_mode_alarm)?), }; + let update_policy = self.update_policy()?; + let miner_options = self.miner_options()?; let logger_config = self.logger_config(); - let http_conf = try!(self.http_config()); - let ipc_conf = try!(self.ipc_config()); - let net_conf = try!(self.net_config()); + let http_conf = self.http_config()?; + let ipc_conf = self.ipc_config()?; + let net_conf = self.net_config()?; let network_id = self.network_id(); let cache_config = self.cache_config(); - let spec = try!(self.chain().parse()); - let tracing = try!(self.args.flag_tracing.parse()); - let fat_db = try!(self.args.flag_fat_db.parse()); - let compaction = try!(self.args.flag_db_compaction.parse()); + let spec = self.chain().parse()?; + let tracing = self.args.flag_tracing.parse()?; + let fat_db = self.args.flag_fat_db.parse()?; + let compaction = self.args.flag_db_compaction.parse()?; let wal = !self.args.flag_fast_and_loose; let warp_sync = self.args.flag_warp; let geth_compatibility = self.args.flag_geth; let ui_address = self.ui_port().map(|port| (self.ui_interface(), port)); let dapps_conf = self.dapps_config(); let signer_conf = self.signer_config(); - let format = try!(self.format()); + let format = self.format()?; let cmd = if self.args.flag_version { Cmd::Version @@ -237,8 +237,8 @@ impl Configuration { wal: wal, tracing: tracing, fat_db: fat_db, - from_block: try!(to_block_id(&self.args.flag_from)), - to_block: try!(to_block_id(&self.args.flag_to)), + from_block: to_block_id(&self.args.flag_from)?, + to_block: to_block_id(&self.args.flag_to)?, check_seal: !self.args.flag_no_seal_check, }; Cmd::Blockchain(BlockchainCmd::Export(export_cmd)) @@ -255,7 +255,7 @@ impl Configuration { wal: wal, tracing: tracing, fat_db: fat_db, - at: try!(to_block_id(&self.args.flag_at)), + at: to_block_id(&self.args.flag_at)?, storage: !self.args.flag_no_storage, code: !self.args.flag_no_code, min_balance: self.args.flag_min_balance.and_then(|s| to_u256(&s).ok()), @@ -278,7 +278,7 @@ impl Configuration { file_path: self.args.arg_file.clone(), wal: wal, kind: snapshot::Kind::Take, - block_at: try!(to_block_id(&self.args.flag_at)), + block_at: to_block_id(&self.args.flag_at)?, }; Cmd::Snapshot(snapshot_cmd) } else if self.args.cmd_restore { @@ -294,7 +294,7 @@ impl Configuration { file_path: self.args.arg_file.clone(), wal: wal, kind: snapshot::Kind::Restore, - block_at: try!(to_block_id("latest")), // unimportant. + block_at: to_block_id("latest")?, // unimportant. }; Cmd::Snapshot(restore_cmd) } else { @@ -319,9 +319,9 @@ impl Configuration { ipc_conf: ipc_conf, net_conf: net_conf, network_id: network_id, - acc_conf: try!(self.accounts_config()), - gas_pricer: try!(self.gas_pricer_config()), - miner_extras: try!(self.miner_extras()), + acc_conf: self.accounts_config()?, + gas_pricer: self.gas_pricer_config()?, + miner_extras: self.miner_extras()?, update_policy: update_policy, mode: mode, tracing: tracing, @@ -362,12 +362,12 @@ impl Configuration { fn miner_extras(&self) -> Result { let extras = MinerExtras { - author: try!(self.author()), - extra_data: try!(self.extra_data()), - gas_floor_target: try!(to_u256(&self.args.flag_gas_floor_target)), - gas_ceil_target: try!(to_u256(&self.args.flag_gas_cap)), + author: self.author()?, + extra_data: self.extra_data()?, + gas_floor_target: to_u256(&self.args.flag_gas_floor_target)?, + gas_ceil_target: to_u256(&self.args.flag_gas_cap)?, transactions_limit: self.args.flag_tx_queue_size, - engine_signer: try!(self.engine_signer()), + engine_signer: self.engine_signer()?, }; Ok(extras) @@ -383,7 +383,7 @@ impl Configuration { fn format(&self) -> Result, String> { match self.args.flag_format { - Some(ref f) => Ok(Some(try!(f.parse()))), + Some(ref f) => Ok(Some(f.parse()?)), None => Ok(None), } } @@ -451,14 +451,14 @@ impl Configuration { iterations: self.args.flag_keys_iterations, testnet: self.args.flag_testnet, password_files: self.args.flag_password.clone(), - unlocked_accounts: try!(to_addresses(&self.args.flag_unlock)), + unlocked_accounts: to_addresses(&self.args.flag_unlock)?, }; Ok(cfg) } fn miner_options(&self) -> Result { - let reseal = try!(self.args.flag_reseal_on_txs.parse::()); + let reseal = self.args.flag_reseal_on_txs.parse::()?; let options = MinerOptions { new_work_notify: self.work_notify(), @@ -466,13 +466,13 @@ impl Configuration { reseal_on_external_tx: reseal.external, reseal_on_own_tx: reseal.own, tx_gas_limit: match self.args.flag_tx_gas_limit { - Some(ref d) => try!(to_u256(d)), + Some(ref d) => to_u256(d)?, None => U256::max_value(), }, tx_queue_size: self.args.flag_tx_queue_size, - tx_queue_gas_limit: try!(to_gas_limit(&self.args.flag_tx_queue_gas)), - tx_queue_strategy: try!(to_queue_strategy(&self.args.flag_tx_queue_strategy)), - pending_set: try!(to_pending_set(&self.args.flag_relay_set)), + tx_queue_gas_limit: to_gas_limit(&self.args.flag_tx_queue_gas)?, + tx_queue_strategy: to_queue_strategy(&self.args.flag_tx_queue_strategy)?, + pending_set: to_pending_set(&self.args.flag_relay_set)?, reseal_min_period: Duration::from_millis(self.args.flag_reseal_min_period), work_queue_size: self.args.flag_work_queue_size, enable_resubmission: !self.args.flag_remove_solved, @@ -513,18 +513,18 @@ impl Configuration { fn gas_pricer_config(&self) -> Result { if let Some(d) = self.args.flag_gasprice.as_ref() { - return Ok(GasPricerConfig::Fixed(try!(to_u256(d)))); + return Ok(GasPricerConfig::Fixed(to_u256(d)?)); } - let usd_per_tx = try!(to_price(&self.args.flag_usd_per_tx)); + let usd_per_tx = to_price(&self.args.flag_usd_per_tx)?; if "auto" == self.args.flag_usd_per_eth.as_str() { return Ok(GasPricerConfig::Calibrated { usd_per_tx: usd_per_tx, - recalibration_period: try!(to_duration(self.args.flag_price_update_period.as_str())), + recalibration_period: to_duration(self.args.flag_price_update_period.as_str())?, }); } - let usd_per_eth = try!(to_price(&self.args.flag_usd_per_eth)); + let usd_per_eth = to_price(&self.args.flag_usd_per_eth)?; let wei_per_usd: f32 = 1.0e18 / usd_per_eth; let gas_per_tx: f32 = 21000.0; let wei_per_gas: f32 = wei_per_usd * usd_per_tx / gas_per_tx; @@ -552,8 +552,8 @@ impl Configuration { match self.args.flag_reserved_peers { Some(ref path) => { let mut buffer = String::new(); - let mut node_file = try!(File::open(path).map_err(|e| format!("Error opening reserved nodes file: {}", e))); - try!(node_file.read_to_string(&mut buffer).map_err(|_| "Error reading reserved node file")); + let mut node_file = File::open(path).map_err(|e| format!("Error opening reserved nodes file: {}", e))?; + node_file.read_to_string(&mut buffer).map_err(|_| "Error reading reserved node file")?; let lines = buffer.lines().map(|s| s.trim().to_owned()).filter(|s| !s.is_empty()).collect::>(); if let Some(invalid) = lines.iter().find(|s| !is_valid_node_url(s)) { return Err(format!("Invalid node address format given for a boot node: {}", invalid)); @@ -569,7 +569,7 @@ impl Configuration { let listen_address = Some(SocketAddr::new("0.0.0.0".parse().unwrap(), port)); let public_address = if self.args.flag_nat.starts_with("extip:") { let host = &self.args.flag_nat[6..]; - let host = try!(host.parse().map_err(|_| format!("Invalid host given with `--nat extip:{}`", host))); + let host = host.parse().map_err(|_| format!("Invalid host given with `--nat extip:{}`", host))?; Some(SocketAddr::new(host, port)) } else { None @@ -580,8 +580,8 @@ impl Configuration { fn net_config(&self) -> Result { let mut ret = NetworkConfiguration::new(); ret.nat_enabled = self.args.flag_nat == "any" || self.args.flag_nat == "upnp"; - ret.boot_nodes = try!(to_bootnodes(&self.args.flag_bootnodes)); - let (listen, public) = try!(self.net_addresses()); + ret.boot_nodes = to_bootnodes(&self.args.flag_bootnodes)?; + let (listen, public) = self.net_addresses()?; ret.listen_address = listen.map(|l| format!("{}", l)); ret.public_address = public.map(|p| format!("{}", p)); ret.use_secret = self.args.flag_node_key.as_ref().map(|s| s.parse::().unwrap_or_else(|_| s.sha3())); @@ -589,12 +589,12 @@ impl Configuration { ret.max_peers = self.max_peers(); ret.min_peers = self.min_peers(); ret.snapshot_peers = self.snapshot_peers(); - ret.allow_ips = try!(self.allow_ips()); + ret.allow_ips = self.allow_ips()?; ret.max_pending_peers = self.max_pending_peers(); let mut net_path = PathBuf::from(self.directories().base); net_path.push("network"); ret.config_path = Some(net_path.to_str().unwrap().to_owned()); - ret.reserved_nodes = try!(self.init_reserved_nodes()); + ret.reserved_nodes = self.init_reserved_nodes()?; ret.allow_non_reserved = !self.args.flag_reserved_only; Ok(ret) } @@ -651,7 +651,7 @@ impl Configuration { } apis.push_str("personal"); } - try!(apis.parse()) + apis.parse()? }, }; @@ -663,7 +663,7 @@ impl Configuration { enabled: !self.args.flag_jsonrpc_off && !self.args.flag_no_jsonrpc, interface: self.rpc_interface(), port: self.args.flag_rpcport.unwrap_or(self.args.flag_jsonrpc_port), - apis: try!(self.rpc_apis().parse()), + apis: self.rpc_apis().parse()?, hosts: self.rpc_hosts(), cors: self.rpc_cors(), }; diff --git a/parity/dapps.rs b/parity/dapps.rs index 698c0616e..fde3febd8 100644 --- a/parity/dapps.rs +++ b/parity/dapps.rs @@ -67,7 +67,7 @@ pub fn new(configuration: Configuration, deps: Dependencies) -> Result Result Result<(), String> { - try!(fs::create_dir_all(&self.base).map_err(|e| e.to_string())); - try!(fs::create_dir_all(&self.db).map_err(|e| e.to_string())); - try!(fs::create_dir_all(&self.keys).map_err(|e| e.to_string())); + fs::create_dir_all(&self.base).map_err(|e| e.to_string())?; + fs::create_dir_all(&self.db).map_err(|e| e.to_string())?; + fs::create_dir_all(&self.keys).map_err(|e| e.to_string())?; if signer_enabled { - try!(fs::create_dir_all(&self.signer).map_err(|e| e.to_string())); + fs::create_dir_all(&self.signer).map_err(|e| e.to_string())?; } if dapps_enabled { - try!(fs::create_dir_all(&self.dapps).map_err(|e| e.to_string())); + fs::create_dir_all(&self.dapps).map_err(|e| e.to_string())?; } Ok(()) } diff --git a/parity/helpers.rs b/parity/helpers.rs index 74e5bab63..b91b62f1d 100644 --- a/parity/helpers.rs +++ b/parity/helpers.rs @@ -97,7 +97,7 @@ pub fn to_gas_limit(s: &str) -> Result { match s { "auto" => Ok(GasLimit::Auto), "off" => Ok(GasLimit::None), - other => Ok(GasLimit::Fixed(try!(to_u256(other)))), + other => Ok(GasLimit::Fixed(to_u256(other)?)), } } @@ -288,12 +288,12 @@ pub fn password_prompt() -> Result { print!("Type password: "); flush_stdout(); - let password = try!(read_password().map_err(|_| STDIN_ERROR.to_owned())); + let password = read_password().map_err(|_| STDIN_ERROR.to_owned())?; print!("Repeat password: "); flush_stdout(); - let password_repeat = try!(read_password().map_err(|_| STDIN_ERROR.to_owned())); + let password_repeat = read_password().map_err(|_| STDIN_ERROR.to_owned())?; if password != password_repeat { return Err("Passwords do not match!".into()); @@ -304,7 +304,7 @@ pub fn password_prompt() -> Result { /// Read a password from password file. pub fn password_from_file(path: String) -> Result { - let passwords = try!(passwords_from_files(&[path])); + let passwords = passwords_from_files(&[path])?; // use only first password from the file passwords.get(0).map(String::to_owned) .ok_or_else(|| "Password file seems to be empty.".to_owned()) @@ -313,7 +313,7 @@ pub fn password_from_file(path: String) -> Result { /// Reads passwords from files. Treats each line as a separate password. pub fn passwords_from_files(files: &[String]) -> Result, String> { let passwords = files.iter().map(|filename| { - let file = try!(File::open(filename).map_err(|_| format!("{} Unable to read password file. Ensure it exists and permissions are correct.", filename))); + let file = File::open(filename).map_err(|_| format!("{} Unable to read password file. Ensure it exists and permissions are correct.", filename))?; let reader = BufReader::new(&file); let lines = reader.lines() .filter_map(|l| l.ok()) @@ -321,7 +321,7 @@ pub fn passwords_from_files(files: &[String]) -> Result, String> { .collect::>(); Ok(lines) }).collect::>, String>>(); - Ok(try!(passwords).into_iter().flat_map(|x| x).collect()) + Ok(passwords?.into_iter().flat_map(|x| x).collect()) } #[cfg(test)] diff --git a/parity/main.rs b/parity/main.rs index 6bab26cc3..7d2be8fb0 100644 --- a/parity/main.rs +++ b/parity/main.rs @@ -131,8 +131,8 @@ use dir::default_hypervisor_path; fn print_hash_of(maybe_file: Option) -> Result { if let Some(file) = maybe_file { - let mut f = BufReader::new(try!(File::open(&file).map_err(|_| "Unable to open file".to_owned()))); - let hash = try!(sha3(&mut f).map_err(|_| "Unable to read from file".to_owned())); + let mut f = BufReader::new(File::open(&file).map_err(|_| "Unable to open file".to_owned())?); + let hash = sha3(&mut f).map_err(|_| "Unable to read from file".to_owned())?; Ok(hash.hex()) } else { Err("Streaming from standard input not yet supported. Specify a file.".to_owned()) @@ -175,7 +175,7 @@ fn start(can_restart: bool) -> Result { println!("{}", d); } - let cmd = try!(conf.into_command()); + let cmd = conf.into_command()?; execute(cmd, can_restart) } diff --git a/parity/migration.rs b/parity/migration.rs index 8a6f4435a..32a7ea663 100644 --- a/parity/migration.rs +++ b/parity/migration.rs @@ -104,7 +104,7 @@ fn current_version(path: &Path) -> Result { Err(_) => Err(Error::UnknownDatabaseVersion), Ok(mut file) => { let mut s = String::new(); - try!(file.read_to_string(&mut s).map_err(|_| Error::UnknownDatabaseVersion)); + file.read_to_string(&mut s).map_err(|_| Error::UnknownDatabaseVersion)?; u32::from_str_radix(&s, 10).map_err(|_| Error::UnknownDatabaseVersion) }, } @@ -113,9 +113,9 @@ fn current_version(path: &Path) -> Result { /// Writes current database version to the file. /// Creates a new file if the version file does not exist yet. fn update_version(path: &Path) -> Result<(), Error> { - try!(fs::create_dir_all(path)); - let mut file = try!(File::create(version_file_path(path))); - try!(file.write_all(format!("{}", CURRENT_VERSION).as_bytes())); + fs::create_dir_all(path)?; + let mut file = File::create(version_file_path(path))?; + file.write_all(format!("{}", CURRENT_VERSION).as_bytes())?; Ok(()) } @@ -145,7 +145,7 @@ pub fn default_migration_settings(compaction_profile: &CompactionProfile) -> Mig /// Migrations on the consolidated database. fn consolidated_database_migrations(compaction_profile: &CompactionProfile) -> Result { let mut manager = MigrationManager::new(default_migration_settings(compaction_profile)); - try!(manager.add_migration(migrations::ToV10::new()).map_err(|_| Error::MigrationImpossible)); + manager.add_migration(migrations::ToV10::new()).map_err(|_| Error::MigrationImpossible)?; Ok(manager) } @@ -171,16 +171,16 @@ fn consolidate_database( wal: true, }; - let old_path_str = try!(old_db_path.to_str().ok_or(Error::MigrationImpossible)); - let new_path_str = try!(new_db_path.to_str().ok_or(Error::MigrationImpossible)); + let old_path_str = old_db_path.to_str().ok_or(Error::MigrationImpossible)?; + let new_path_str = new_db_path.to_str().ok_or(Error::MigrationImpossible)?; - let cur_db = Arc::new(try!(Database::open(&db_config, old_path_str).map_err(db_error))); + let cur_db = Arc::new(Database::open(&db_config, old_path_str).map_err(db_error)?); // open new DB with proper number of columns db_config.columns = migration.columns(); - let mut new_db = try!(Database::open(&db_config, new_path_str).map_err(db_error)); + let mut new_db = Database::open(&db_config, new_path_str).map_err(db_error)?; // Migrate to new database (default column only) - try!(migration.migrate(cur_db, &config, &mut new_db, None)); + migration.migrate(cur_db, &config, &mut new_db, None)?; Ok(()) } @@ -198,20 +198,20 @@ fn migrate_database(version: u32, db_path: PathBuf, mut migrations: MigrationMan let _ = fs::remove_dir_all(&backup_path); // migrate old database to the new one - let temp_path = try!(migrations.execute(&db_path, version)); + let temp_path = migrations.execute(&db_path, version)?; // create backup - try!(fs::rename(&db_path, &backup_path)); + fs::rename(&db_path, &backup_path)?; // replace the old database with the new one if let Err(err) = fs::rename(&temp_path, &db_path) { // if something went wrong, bring back backup - try!(fs::rename(&backup_path, &db_path)); + fs::rename(&backup_path, &db_path)?; return Err(err.into()); } // remove backup - try!(fs::remove_dir_all(&backup_path)); + fs::remove_dir_all(&backup_path)?; Ok(()) } @@ -223,7 +223,7 @@ fn exists(path: &Path) -> bool { /// Migrates the database. pub fn migrate(path: &Path, pruning: Algorithm, compaction_profile: CompactionProfile) -> Result<(), Error> { // read version file. - let version = try!(current_version(path)); + let version = current_version(path)?; // migrate the databases. // main db directory may already exists, so let's check if we have blocks dir @@ -240,18 +240,18 @@ pub fn migrate(path: &Path, pruning: Algorithm, compaction_profile: CompactionPr if version < CONSOLIDATION_VERSION && exists(&legacy::blocks_database_path(path)) { println!("Migrating database from version {} to {}", version, CONSOLIDATION_VERSION); - try!(migrate_database(version, legacy::extras_database_path(path), try!(legacy::extras_database_migrations(&compaction_profile)))); - try!(migrate_database(version, legacy::state_database_path(path), try!(legacy::state_database_migrations(pruning, &compaction_profile)))); - try!(migrate_database(version, legacy::blocks_database_path(path), try!(legacy::blocks_database_migrations(&compaction_profile)))); + migrate_database(version, legacy::extras_database_path(path), legacy::extras_database_migrations(&compaction_profile)?)?; + migrate_database(version, legacy::state_database_path(path), legacy::state_database_migrations(pruning, &compaction_profile)?)?; + migrate_database(version, legacy::blocks_database_path(path), legacy::blocks_database_migrations(&compaction_profile)?)?; let db_path = consolidated_database_path(path); // Remove the database dir (it shouldn't exist anyway, but it might when migration was interrupted) let _ = fs::remove_dir_all(db_path.clone()); - try!(consolidate_database(legacy::blocks_database_path(path), db_path.clone(), db::COL_HEADERS, Extract::Header, &compaction_profile)); - try!(consolidate_database(legacy::blocks_database_path(path), db_path.clone(), db::COL_BODIES, Extract::Body, &compaction_profile)); - try!(consolidate_database(legacy::extras_database_path(path), db_path.clone(), db::COL_EXTRA, Extract::All, &compaction_profile)); - try!(consolidate_database(legacy::state_database_path(path), db_path.clone(), db::COL_STATE, Extract::All, &compaction_profile)); - try!(consolidate_database(legacy::trace_database_path(path), db_path.clone(), db::COL_TRACE, Extract::All, &compaction_profile)); + consolidate_database(legacy::blocks_database_path(path), db_path.clone(), db::COL_HEADERS, Extract::Header, &compaction_profile)?; + consolidate_database(legacy::blocks_database_path(path), db_path.clone(), db::COL_BODIES, Extract::Body, &compaction_profile)?; + consolidate_database(legacy::extras_database_path(path), db_path.clone(), db::COL_EXTRA, Extract::All, &compaction_profile)?; + consolidate_database(legacy::state_database_path(path), db_path.clone(), db::COL_STATE, Extract::All, &compaction_profile)?; + consolidate_database(legacy::trace_database_path(path), db_path.clone(), db::COL_TRACE, Extract::All, &compaction_profile)?; let _ = fs::remove_dir_all(legacy::blocks_database_path(path)); let _ = fs::remove_dir_all(legacy::extras_database_path(path)); let _ = fs::remove_dir_all(legacy::state_database_path(path)); @@ -265,7 +265,7 @@ pub fn migrate(path: &Path, pruning: Algorithm, compaction_profile: CompactionPr // Further migrations if version >= CONSOLIDATION_VERSION && version < CURRENT_VERSION && exists(&consolidated_database_path(path)) { println!("Migrating database from version {} to {}", ::std::cmp::max(CONSOLIDATION_VERSION, version), CURRENT_VERSION); - try!(migrate_database(version, consolidated_database_path(path), try!(consolidated_database_migrations(&compaction_profile)))); + migrate_database(version, consolidated_database_path(path), consolidated_database_migrations(&compaction_profile)?)?; println!("Migration finished"); } @@ -313,14 +313,14 @@ mod legacy { /// Migrations on the blocks database. pub fn blocks_database_migrations(compaction_profile: &CompactionProfile) -> Result { let mut manager = MigrationManager::new(default_migration_settings(compaction_profile)); - try!(manager.add_migration(migrations::blocks::V8::default()).map_err(|_| Error::MigrationImpossible)); + manager.add_migration(migrations::blocks::V8::default()).map_err(|_| Error::MigrationImpossible)?; Ok(manager) } /// Migrations on the extras database. pub fn extras_database_migrations(compaction_profile: &CompactionProfile) -> Result { let mut manager = MigrationManager::new(default_migration_settings(compaction_profile)); - try!(manager.add_migration(migrations::extras::ToV6).map_err(|_| Error::MigrationImpossible)); + manager.add_migration(migrations::extras::ToV6).map_err(|_| Error::MigrationImpossible)?; Ok(manager) } @@ -333,7 +333,7 @@ mod legacy { _ => return Err(Error::UnsupportedPruningMethod), }; - try!(res.map_err(|_| Error::MigrationImpossible)); + res.map_err(|_| Error::MigrationImpossible)?; Ok(manager) } } diff --git a/parity/modules.rs b/parity/modules.rs index bf2eeb0fb..83f955992 100644 --- a/parity/modules.rs +++ b/parity/modules.rs @@ -171,13 +171,13 @@ pub fn sync ) -> Result { - let eth_sync = try!(EthSync::new(Params { + let eth_sync = EthSync::new(Params { config: sync_cfg, chain: client, provider: provider, snapshot_service: snapshot_service, network_config: net_cfg, - })); + })?; Ok((eth_sync.clone() as Arc, eth_sync.clone() as Arc, eth_sync.clone() as Arc)) } diff --git a/parity/params.rs b/parity/params.rs index 9f549acee..bc1950165 100644 --- a/parity/params.rs +++ b/parity/params.rs @@ -71,7 +71,7 @@ impl SpecType { SpecType::Expanse => Ok(ethereum::new_expanse()), SpecType::Dev => Ok(Spec::new_instant()), SpecType::Custom(ref filename) => { - let file = try!(fs::File::open(filename).map_err(|_| "Could not load specification file.")); + let file = fs::File::open(filename).map_err(|_| "Could not load specification file.")?; Spec::load(file) } } diff --git a/parity/presale.rs b/parity/presale.rs index d8e19a96a..02ae8dfdd 100644 --- a/parity/presale.rs +++ b/parity/presale.rs @@ -31,15 +31,15 @@ pub struct ImportWallet { pub fn execute(cmd: ImportWallet) -> Result { let password: String = match cmd.password_file { - Some(file) => try!(password_from_file(file)), - None => try!(password_prompt()), + Some(file) => password_from_file(file)?, + None => password_prompt()?, }; let dir = Box::new(DiskDirectory::create(cmd.path).unwrap()); let secret_store = Box::new(EthStore::open_with_iterations(dir, cmd.iterations).unwrap()); let acc_provider = AccountProvider::new(secret_store); - let wallet = try!(PresaleWallet::open(cmd.wallet_path).map_err(|_| "Unable to open presale wallet.")); - let kp = try!(wallet.decrypt(&password).map_err(|_| "Invalid password.")); + let wallet = PresaleWallet::open(cmd.wallet_path).map_err(|_| "Unable to open presale wallet.")?; + let kp = wallet.decrypt(&password).map_err(|_| "Invalid password.")?; let address = acc_provider.insert_account(*kp.secret(), &password).unwrap(); Ok(format!("{:?}", address)) } diff --git a/parity/rpc.rs b/parity/rpc.rs index f5ff05e20..4fe126e89 100644 --- a/parity/rpc.rs +++ b/parity/rpc.rs @@ -89,8 +89,8 @@ pub fn new_http(conf: HttpConfiguration, deps: &Dependencies) -> Result Result { @@ -105,7 +105,7 @@ pub fn setup_http_rpc_server( allowed_hosts: Option>, apis: ApiSet ) -> Result { - let server = try!(setup_rpc_server(apis, dependencies)); + let server = setup_rpc_server(apis, dependencies)?; let ph = dependencies.panic_handler.clone(); let start_result = server.start_http(url, cors_domains, allowed_hosts, ph); match start_result { @@ -120,11 +120,11 @@ pub fn setup_http_rpc_server( pub fn new_ipc(conf: IpcConfiguration, deps: &Dependencies) -> Result, String> { if !conf.enabled { return Ok(None); } - Ok(Some(try!(setup_ipc_rpc_server(deps, &conf.socket_addr, conf.apis)))) + Ok(Some(setup_ipc_rpc_server(deps, &conf.socket_addr, conf.apis)?)) } pub fn setup_ipc_rpc_server(dependencies: &Dependencies, addr: &str, apis: ApiSet) -> Result { - let server = try!(setup_rpc_server(apis, dependencies)); + let server = setup_rpc_server(apis, dependencies)?; match server.start_ipc(addr) { Err(IpcServerError::Io(io_error)) => Err(format!("RPC io error: {}", io_error)), Err(any_error) => Err(format!("Rpc error: {:?}", any_error)), diff --git a/parity/run.rs b/parity/run.rs index 10f61b5af..8ff385b4a 100644 --- a/parity/run.rs +++ b/parity/run.rs @@ -109,7 +109,7 @@ pub fn open_ui(dapps_conf: &dapps::Configuration, signer_conf: &signer::Configur return Err("Cannot use UI command with UI turned off.".into()) } - let token = try!(signer::generate_token_and_url(signer_conf)); + let token = signer::generate_token_and_url(signer_conf)?; // Open a browser url::open(&token.url); // Print a message @@ -133,7 +133,7 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc) -> R raise_fd_limit(); // load spec - let spec = try!(cmd.spec.spec()); + let spec = cmd.spec.spec()?; // load genesis hash let genesis_hash = spec.genesis_header().hash(); @@ -145,19 +145,19 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc) -> R let user_defaults_path = db_dirs.user_defaults_path(); // load user defaults - let mut user_defaults = try!(UserDefaults::load(&user_defaults_path)); + let mut user_defaults = UserDefaults::load(&user_defaults_path)?; // select pruning algorithm let algorithm = cmd.pruning.to_algorithm(&user_defaults); // check if tracing is on - let tracing = try!(tracing_switch_to_bool(cmd.tracing, &user_defaults)); + let tracing = tracing_switch_to_bool(cmd.tracing, &user_defaults)?; // check if fatdb is on - let fat_db = try!(fatdb_switch_to_bool(cmd.fat_db, &user_defaults, algorithm)); + let fat_db = fatdb_switch_to_bool(cmd.fat_db, &user_defaults, algorithm)?; // get the mode - let mode = try!(mode_switch_to_bool(cmd.mode, &user_defaults)); + let mode = mode_switch_to_bool(cmd.mode, &user_defaults)?; trace!(target: "mode", "mode is {:?}", mode); let network_enabled = match mode { Mode::Dark(_) | Mode::Off => false, _ => true, }; @@ -169,14 +169,14 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc) -> R let snapshot_path = db_dirs.snapshot_path(); // execute upgrades - try!(execute_upgrades(&cmd.dirs.base, &db_dirs, algorithm, cmd.compaction.compaction_profile(db_dirs.db_root_path().as_path()))); + execute_upgrades(&cmd.dirs.base, &db_dirs, algorithm, cmd.compaction.compaction_profile(db_dirs.db_root_path().as_path()))?; // create dirs used by parity - try!(cmd.dirs.create_dirs(cmd.dapps_conf.enabled, cmd.signer_conf.enabled)); + cmd.dirs.create_dirs(cmd.dapps_conf.enabled, cmd.signer_conf.enabled)?; // run in daemon mode if let Some(pid_file) = cmd.daemon { - try!(daemonize(pid_file)); + daemonize(pid_file)?; } // display info about used pruning algorithm @@ -214,10 +214,10 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc) -> R sync_config.warp_sync = cmd.warp_sync; sync_config.download_old_blocks = cmd.download_old_blocks; - let passwords = try!(passwords_from_files(&cmd.acc_conf.password_files)); + let passwords = passwords_from_files(&cmd.acc_conf.password_files)?; // prepare account provider - let account_provider = Arc::new(try!(prepare_account_provider(&cmd.dirs, &spec.data_dir, cmd.acc_conf, &passwords))); + let account_provider = Arc::new(prepare_account_provider(&cmd.dirs, &spec.data_dir, cmd.acc_conf, &passwords)?); // let the Engine access the accounts spec.engine.register_account_provider(account_provider.clone()); @@ -266,14 +266,14 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc) -> R let mut hypervisor = modules::hypervisor(&cmd.dirs.ipc_path()); // create client service. - let service = try!(ClientService::start( + let service = ClientService::start( client_config, &spec, &client_path, &snapshot_path, &cmd.dirs.ipc_path(), miner.clone(), - ).map_err(|e| format!("Client service error: {:?}", e))); + ).map_err(|e| format!("Client service error: {:?}", e))?; // drop the spec to free up genesis state. drop(spec); @@ -289,7 +289,7 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc) -> R let external_miner = Arc::new(ExternalMiner::default()); // create sync object - let (sync_provider, manage_network, chain_notify) = try!(modules::sync( + let (sync_provider, manage_network, chain_notify) = modules::sync( &mut hypervisor, sync_config, net_conf.into(), @@ -297,7 +297,7 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc) -> R snapshot_service.clone(), client.clone(), &cmd.logger_config, - ).map_err(|e| format!("Sync error: {}", e))); + ).map_err(|e| format!("Sync error: {}", e))?; service.add_notify(chain_notify.clone()); @@ -310,7 +310,7 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc) -> R let event_loop = EventLoop::spawn(); // fetch service - let fetch = try!(FetchClient::new().map_err(|e| format!("Error starting fetch client: {:?}", e))); + let fetch = FetchClient::new().map_err(|e| format!("Error starting fetch client: {:?}", e))?; // the updater service let updater = Updater::new( @@ -359,8 +359,8 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc) -> R }; // start rpc servers - let http_server = try!(rpc::new_http(cmd.http_conf, &dependencies)); - let ipc_server = try!(rpc::new_ipc(cmd.ipc_conf, &dependencies)); + let http_server = rpc::new_http(cmd.http_conf, &dependencies)?; + let ipc_server = rpc::new_ipc(cmd.ipc_conf, &dependencies)?; // the dapps server let dapps_deps = dapps::Dependencies { @@ -372,14 +372,14 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc) -> R fetch: fetch.clone(), signer: deps_for_rpc_apis.signer_service.clone(), }; - let dapps_server = try!(dapps::new(cmd.dapps_conf.clone(), dapps_deps)); + let dapps_server = dapps::new(cmd.dapps_conf.clone(), dapps_deps)?; // the signer server let signer_deps = signer::Dependencies { panic_handler: panic_handler.clone(), apis: deps_for_rpc_apis.clone(), }; - let signer_server = try!(signer::start(cmd.signer_conf.clone(), signer_deps)); + let signer_server = signer::start(cmd.signer_conf.clone(), signer_deps)?; // the informant let informant = Arc::new(Informant::new( @@ -397,7 +397,7 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc) -> R user_defaults.tracing = tracing; user_defaults.fat_db = fat_db; user_defaults.mode = mode; - try!(user_defaults.save(&user_defaults_path)); + user_defaults.save(&user_defaults_path)?; // tell client how to save the default mode if it gets changed. client.on_mode_change(move |mode: &Mode| { @@ -425,7 +425,7 @@ pub fn execute(cmd: RunCmd, can_restart: bool, logger: Arc) -> R // start ui if cmd.ui { - try!(open_ui(&cmd.dapps_conf, &cmd.signer_conf)); + open_ui(&cmd.dapps_conf, &cmd.signer_conf)?; } // Handle exit @@ -477,9 +477,9 @@ fn prepare_account_provider(dirs: &Directories, data_dir: &str, cfg: AccountsCon let path = dirs.keys_path(data_dir); upgrade_key_location(&dirs.legacy_keys_path(cfg.testnet), &path); - let dir = Box::new(try!(DiskDirectory::create(&path).map_err(|e| format!("Could not open keys directory: {}", e)))); + let dir = Box::new(DiskDirectory::create(&path).map_err(|e| format!("Could not open keys directory: {}", e))?); let account_service = AccountProvider::new(Box::new( - try!(EthStore::open_with_iterations(dir, cfg.iterations).map_err(|e| format!("Could not open keys directory: {}", e))) + EthStore::open_with_iterations(dir, cfg.iterations).map_err(|e| format!("Could not open keys directory: {}", e))? )); for a in cfg.unlocked_accounts { diff --git a/parity/signer.rs b/parity/signer.rs index b4b3679ef..43bb080da 100644 --- a/parity/signer.rs +++ b/parity/signer.rs @@ -65,7 +65,7 @@ pub fn start(conf: Configuration, deps: Dependencies) -> Result PathBuf { } pub fn execute(cmd: Configuration) -> Result { - Ok(try!(generate_token_and_url(&cmd)).message) + Ok(generate_token_and_url(&cmd)?.message) } pub fn generate_token_and_url(conf: &Configuration) -> Result { - let code = try!(generate_new_token(conf.signer_path.clone()).map_err(|err| format!("Error generating token: {:?}", err))); + let code = generate_new_token(conf.signer_path.clone()).map_err(|err| format!("Error generating token: {:?}", err))?; let auth_url = format!("http://{}:{}/#/auth?token={}", conf.interface, conf.port, code); // And print in to the console Ok(NewToken { @@ -101,18 +101,18 @@ Or use the generated token: pub fn generate_new_token(path: String) -> io::Result { let path = codes_path(path); - let mut codes = try!(signer::AuthCodes::from_file(&path)); + let mut codes = signer::AuthCodes::from_file(&path)?; codes.clear_garbage(); - let code = try!(codes.generate_new()); - try!(codes.to_file(&path)); + let code = codes.generate_new()?; + codes.to_file(&path)?; trace!("New key code created: {}", Colour::White.bold().paint(&code[..])); Ok(code) } fn do_start(conf: Configuration, deps: Dependencies) -> Result { - let addr = try!(format!("{}:{}", conf.interface, conf.port) + let addr = format!("{}:{}", conf.interface, conf.port) .parse() - .map_err(|_| format!("Invalid port specified: {}", conf.port))); + .map_err(|_| format!("Invalid port specified: {}", conf.port))?; let start_result = { let server = signer::ServerBuilder::new( diff --git a/parity/snapshot.rs b/parity/snapshot.rs index 42ba8fec2..4118b6e9c 100644 --- a/parity/snapshot.rs +++ b/parity/snapshot.rs @@ -72,9 +72,9 @@ fn restore_using(snapshot: Arc, reader: &R, info!("Restoring to block #{} (0x{:?})", manifest.block_number, manifest.block_hash); - try!(snapshot.init_restore(manifest.clone(), recover).map_err(|e| { + snapshot.init_restore(manifest.clone(), recover).map_err(|e| { format!("Failed to begin restoration: {}", e) - })); + })?; let (num_state, num_blocks) = (manifest.state_hashes.len(), manifest.block_hashes.len()); @@ -93,8 +93,8 @@ fn restore_using(snapshot: Arc, reader: &R, return Err("Restoration failed".into()); } - let chunk = try!(reader.chunk(state_hash) - .map_err(|e| format!("Encountered error while reading chunk {:?}: {}", state_hash, e))); + let chunk = reader.chunk(state_hash) + .map_err(|e| format!("Encountered error while reading chunk {:?}: {}", state_hash, e))?; let hash = chunk.sha3(); if hash != state_hash { @@ -110,8 +110,8 @@ fn restore_using(snapshot: Arc, reader: &R, return Err("Restoration failed".into()); } - let chunk = try!(reader.chunk(block_hash) - .map_err(|e| format!("Encountered error while reading chunk {:?}: {}", block_hash, e))); + let chunk = reader.chunk(block_hash) + .map_err(|e| format!("Encountered error while reading chunk {:?}: {}", block_hash, e))?; let hash = chunk.sha3(); if hash != block_hash { @@ -137,7 +137,7 @@ impl SnapshotCommand { let panic_handler = PanicHandler::new_in_arc(); // load spec file - let spec = try!(self.spec.spec()); + let spec = self.spec.spec()?; // load genesis hash let genesis_hash = spec.genesis_header().hash(); @@ -149,7 +149,7 @@ impl SnapshotCommand { let user_defaults_path = db_dirs.user_defaults_path(); // load user defaults - let user_defaults = try!(UserDefaults::load(&user_defaults_path)); + let user_defaults = UserDefaults::load(&user_defaults_path)?; fdlimit::raise_fd_limit(); @@ -157,36 +157,36 @@ impl SnapshotCommand { let algorithm = self.pruning.to_algorithm(&user_defaults); // check if tracing is on - let tracing = try!(tracing_switch_to_bool(self.tracing, &user_defaults)); + let tracing = tracing_switch_to_bool(self.tracing, &user_defaults)?; // check if fatdb is on - let fat_db = try!(fatdb_switch_to_bool(self.fat_db, &user_defaults, algorithm)); + let fat_db = fatdb_switch_to_bool(self.fat_db, &user_defaults, algorithm)?; // prepare client and snapshot paths. let client_path = db_dirs.client_path(algorithm); let snapshot_path = db_dirs.snapshot_path(); // execute upgrades - try!(execute_upgrades(&self.dirs.base, &db_dirs, algorithm, self.compaction.compaction_profile(db_dirs.db_root_path().as_path()))); + execute_upgrades(&self.dirs.base, &db_dirs, algorithm, self.compaction.compaction_profile(db_dirs.db_root_path().as_path()))?; // prepare client config let client_config = to_client_config(&self.cache_config, Mode::Active, tracing, fat_db, self.compaction, self.wal, VMType::default(), "".into(), algorithm, self.pruning_history, true); - let service = try!(ClientService::start( + let service = ClientService::start( client_config, &spec, &client_path, &snapshot_path, &self.dirs.ipc_path(), Arc::new(Miner::with_spec(&spec)) - ).map_err(|e| format!("Client service error: {:?}", e))); + ).map_err(|e| format!("Client service error: {:?}", e))?; Ok((service, panic_handler)) } /// restore from a snapshot pub fn restore(self) -> Result<(), String> { let file = self.file_path.clone(); - let (service, _panic_handler) = try!(self.start_service()); + let (service, _panic_handler) = self.start_service()?; warn!("Snapshot restoration is experimental and the format may be subject to change."); warn!("On encountering an unexpected error, please ensure that you have a recent snapshot."); @@ -200,15 +200,15 @@ impl SnapshotCommand { .map_err(|e| format!("Couldn't open snapshot file: {}", e)) .and_then(|x| x.ok_or("Snapshot file has invalid format.".into())); - let reader = try!(reader); - try!(restore_using(snapshot, &reader, true)); + let reader = reader?; + restore_using(snapshot, &reader, true)?; } else { info!("Attempting to restore from local snapshot."); // attempting restoration with recovery will lead to deadlock // as we currently hold a read lock on the service's reader. match *snapshot.reader() { - Some(ref reader) => try!(restore_using(snapshot.clone(), reader, false)), + Some(ref reader) => restore_using(snapshot.clone(), reader, false)?, None => return Err("No local snapshot found.".into()), } } @@ -218,15 +218,15 @@ impl SnapshotCommand { /// Take a snapshot from the head of the chain. pub fn take_snapshot(self) -> Result<(), String> { - let file_path = try!(self.file_path.clone().ok_or("No file path provided.".to_owned())); + let file_path = self.file_path.clone().ok_or("No file path provided.".to_owned())?; let file_path: PathBuf = file_path.into(); let block_at = self.block_at; - let (service, _panic_handler) = try!(self.start_service()); + let (service, _panic_handler) = self.start_service()?; warn!("Snapshots are currently experimental. File formats may be subject to change."); - let writer = try!(PackedWriter::new(&file_path) - .map_err(|e| format!("Failed to open snapshot writer: {}", e))); + let writer = PackedWriter::new(&file_path) + .map_err(|e| format!("Failed to open snapshot writer: {}", e))?; let progress = Arc::new(Progress::default()); let p = progress.clone(); @@ -254,7 +254,7 @@ impl SnapshotCommand { info!("snapshot creation complete"); assert!(progress.done()); - try!(informant_handle.join().map_err(|_| "failed to join logger thread")); + informant_handle.join().map_err(|_| "failed to join logger thread")?; Ok(()) } @@ -263,8 +263,8 @@ impl SnapshotCommand { /// Execute this snapshot command. pub fn execute(cmd: SnapshotCommand) -> Result { match cmd.kind { - Kind::Take => try!(cmd.take_snapshot()), - Kind::Restore => try!(cmd.restore()), + Kind::Take => cmd.take_snapshot()?, + Kind::Restore => cmd.restore()?, } Ok(String::new()) diff --git a/parity/upgrade.rs b/parity/upgrade.rs index 2963c3d05..bac45cf52 100644 --- a/parity/upgrade.rs +++ b/parity/upgrade.rs @@ -89,7 +89,7 @@ fn upgrade_from_version(previous_version: &Version) -> Result { for upgrade_key in upgrades.keys() { if upgrade_key.is_applicable(previous_version, ¤t_version) { let upgrade_script = upgrades[upgrade_key]; - try!(upgrade_script()); + upgrade_script()?; count += 1; } } @@ -104,7 +104,7 @@ fn with_locked_version(db_path: Option<&str>, script: F) -> Result(db_path: Option<&str>, script: F) -> Result(&mut self, visitor: V) -> Result where V: MapVisitor { - let mut map: BTreeMap = try!(BTreeMapVisitor::new().visit_map(visitor)); - let pruning: Value = try!(map.remove("pruning").ok_or_else(|| Error::custom("missing pruning"))); - let pruning = try!(pruning.as_str().ok_or_else(|| Error::custom("invalid pruning value"))); - let pruning = try!(pruning.parse().map_err(|_| Error::custom("invalid pruning method"))); - let tracing: Value = try!(map.remove("tracing").ok_or_else(|| Error::custom("missing tracing"))); - let tracing = try!(tracing.as_bool().ok_or_else(|| Error::custom("invalid tracing value"))); + let mut map: BTreeMap = BTreeMapVisitor::new().visit_map(visitor)?; + let pruning: Value = map.remove("pruning").ok_or_else(|| Error::custom("missing pruning"))?; + let pruning = pruning.as_str().ok_or_else(|| Error::custom("invalid pruning value"))?; + let pruning = pruning.parse().map_err(|_| Error::custom("invalid pruning method"))?; + let tracing: Value = map.remove("tracing").ok_or_else(|| Error::custom("missing tracing"))?; + let tracing = tracing.as_bool().ok_or_else(|| Error::custom("invalid tracing value"))?; let fat_db: Value = map.remove("fat_db").unwrap_or_else(|| Value::Bool(false)); - let fat_db = try!(fat_db.as_bool().ok_or_else(|| Error::custom("invalid fat_db value"))); + let fat_db = fat_db.as_bool().ok_or_else(|| Error::custom("invalid fat_db value"))?; let mode: Value = map.remove("mode").unwrap_or_else(|| Value::String("active".to_owned())); - let mode = match try!(mode.as_str().ok_or_else(|| Error::custom("invalid mode value"))) { + let mode = match mode.as_str().ok_or_else(|| Error::custom("invalid mode value"))? { "offline" => Mode::Off, "dark" => { - let timeout = try!(map.remove("mode.timeout").and_then(|v| v.as_u64()).ok_or_else(|| Error::custom("invalid/missing mode.timeout value"))); + let timeout = map.remove("mode.timeout").and_then(|v| v.as_u64()).ok_or_else(|| Error::custom("invalid/missing mode.timeout value"))?; Mode::Dark(Duration::from_secs(timeout)) }, "passive" => { - let timeout = try!(map.remove("mode.timeout").and_then(|v| v.as_u64()).ok_or_else(|| Error::custom("invalid/missing mode.timeout value"))); - let alarm = try!(map.remove("mode.alarm").and_then(|v| v.as_u64()).ok_or_else(|| Error::custom("invalid/missing mode.alarm value"))); + let timeout = map.remove("mode.timeout").and_then(|v| v.as_u64()).ok_or_else(|| Error::custom("invalid/missing mode.timeout value"))?; + let alarm = map.remove("mode.alarm").and_then(|v| v.as_u64()).ok_or_else(|| Error::custom("invalid/missing mode.alarm value"))?; Mode::Passive(Duration::from_secs(timeout), Duration::from_secs(alarm)) }, "active" => Mode::Active, @@ -140,7 +140,7 @@ impl UserDefaults { } pub fn save

(&self, path: P) -> Result<(), String> where P: AsRef { - let mut file: File = try!(File::create(path).map_err(|_| "Cannot create user defaults file".to_owned())); + let mut file: File = File::create(path).map_err(|_| "Cannot create user defaults file".to_owned())?; file.write_all(to_string(&self).unwrap().as_bytes()).map_err(|_| "Failed to save user defaults".to_owned()) } } diff --git a/rpc/src/lib.rs b/rpc/src/lib.rs index 8f178cfff..a72f05cdf 100644 --- a/rpc/src/lib.rs +++ b/rpc/src/lib.rs @@ -122,8 +122,8 @@ impl RpcServer { /// Start ipc server asynchronously and returns result with `Server` handle on success or an error. pub fn start_ipc(&self, addr: &str) -> Result { - let server = try!(ipc::Server::new(addr, &self.handler)); - try!(server.run_async()); + let server = ipc::Server::new(addr, &self.handler)?; + server.run_async()?; Ok(server) } } diff --git a/rpc/src/v1/helpers/dispatch.rs b/rpc/src/v1/helpers/dispatch.rs index cc689ddb5..9fd8ab060 100644 --- a/rpc/src/v1/helpers/dispatch.rs +++ b/rpc/src/v1/helpers/dispatch.rs @@ -177,7 +177,7 @@ pub fn sign_no_dispatch(client: &C, miner: &M, accounts: &AccountProvider, }; let hash = t.hash(network_id); - let signature = try!(signature(accounts, address, hash, password)); + let signature = signature(accounts, address, hash, password)?; signature.map(|sig| { t.with_signature(sig, network_id) }) @@ -191,7 +191,7 @@ pub fn sign_and_dispatch(client: &C, miner: &M, accounts: &AccountProvider let network_id = client.signing_network_id(); let min_block = filled.min_block.clone(); - let signed_transaction = try!(sign_no_dispatch(client, miner, accounts, filled, password)); + let signed_transaction = sign_no_dispatch(client, miner, accounts, filled, password)?; let (signed_transaction, token) = match signed_transaction { WithToken::No(signed_transaction) => (signed_transaction, None), diff --git a/rpc/src/v1/helpers/signing_queue.rs b/rpc/src/v1/helpers/signing_queue.rs index 7f5d3a6d1..58b3740cf 100644 --- a/rpc/src/v1/helpers/signing_queue.rs +++ b/rpc/src/v1/helpers/signing_queue.rs @@ -199,7 +199,7 @@ impl ConfirmationsQueue { let recv = recv.expect("Check for none is done earlier."); loop { - let message = try!(recv.recv().map_err(|e| QueueError::ReceiverError(e))); + let message = recv.recv().map_err(|e| QueueError::ReceiverError(e))?; if let QueueEvent::Finish = message { return Ok(()); } diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs index 178377692..953669089 100644 --- a/rpc/src/v1/impls/eth.rs +++ b/rpc/src/v1/impls/eth.rs @@ -277,7 +277,7 @@ impl Eth for EthClient where EM: ExternalMinerService + 'static { fn protocol_version(&self) -> Result { - try!(self.active()); + self.active()?; let version = take_weak!(self.sync).status().protocol_version.to_owned(); Ok(format!("{}", version)) @@ -286,7 +286,7 @@ impl Eth for EthClient where fn syncing(&self) -> Result { use ethcore::snapshot::RestorationStatus; - try!(self.active()); + self.active()?; let status = take_weak!(self.sync).status(); let client = take_weak!(self.client); let snapshot_status = take_weak!(self.snapshot).status(); @@ -317,53 +317,52 @@ impl Eth for EthClient where } fn author(&self) -> Result { - try!(self.active()); + self.active()?; Ok(RpcH160::from(take_weak!(self.miner).author())) } fn is_mining(&self) -> Result { - try!(self.active()); + self.active()?; Ok(take_weak!(self.miner).is_sealing()) } fn hashrate(&self) -> Result { - try!(self.active()); + self.active()?; Ok(RpcU256::from(self.external_miner.hashrate())) } fn gas_price(&self) -> Result { - try!(self.active()); + self.active()?; let (client, miner) = (take_weak!(self.client), take_weak!(self.miner)); Ok(RpcU256::from(default_gas_price(&*client, &*miner))) } fn accounts(&self, id: Trailing) -> Result, Error> { - try!(self.active()); + self.active()?; let dapp = id.0; let store = take_weak!(self.accounts); - let accounts = try!(store + let accounts = store .note_dapp_used(dapp.clone().into()) .and_then(|_| store.dapps_addresses(dapp.into())) - .map_err(|e| errors::internal("Could not fetch accounts.", e)) - ); + .map_err(|e| errors::internal("Could not fetch accounts.", e))?; Ok(accounts.into_iter().map(Into::into).collect()) } fn block_number(&self) -> Result { - try!(self.active()); + self.active()?; Ok(RpcU256::from(take_weak!(self.client).chain_info().best_block_number)) } fn balance(&self, address: RpcH160, num: Trailing) -> Result { - try!(self.active()); + self.active()?; let address = address.into(); match num.0 { @@ -381,7 +380,7 @@ impl Eth for EthClient where } fn storage_at(&self, address: RpcH160, pos: RpcU256, num: Trailing) -> Result { - try!(self.active()); + self.active()?; let address: Address = RpcH160::into(address); let position: U256 = RpcU256::into(pos); match num.0 { @@ -399,7 +398,7 @@ impl Eth for EthClient where } fn transaction_count(&self, address: RpcH160, num: Trailing) -> Result { - try!(self.active()); + self.active()?; let address: Address = RpcH160::into(address); match num.0 { @@ -417,7 +416,7 @@ impl Eth for EthClient where } fn block_transaction_count_by_hash(&self, hash: RpcH256) -> Result, Error> { - try!(self.active()); + self.active()?; Ok( take_weak!(self.client).block(BlockId::Hash(hash.into())) .map(|bytes| BlockView::new(&bytes).transactions_count().into()) @@ -425,7 +424,7 @@ impl Eth for EthClient where } fn block_transaction_count_by_number(&self, num: BlockNumber) -> Result, Error> { - try!(self.active()); + self.active()?; match num { BlockNumber::Pending => Ok(Some( @@ -439,7 +438,7 @@ impl Eth for EthClient where } fn block_uncles_count_by_hash(&self, hash: RpcH256) -> Result, Error> { - try!(self.active()); + self.active()?; Ok( take_weak!(self.client).block(BlockId::Hash(hash.into())) @@ -448,7 +447,7 @@ impl Eth for EthClient where } fn block_uncles_count_by_number(&self, num: BlockNumber) -> Result, Error> { - try!(self.active()); + self.active()?; match num { BlockNumber::Pending => Ok(Some(0.into())), @@ -460,7 +459,7 @@ impl Eth for EthClient where } fn code_at(&self, address: RpcH160, num: Trailing) -> Result { - try!(self.active()); + self.active()?; let address: Address = RpcH160::into(address); match num.0 { @@ -478,39 +477,39 @@ impl Eth for EthClient where } fn block_by_hash(&self, hash: RpcH256, include_txs: bool) -> Result, Error> { - try!(self.active()); + self.active()?; self.block(BlockId::Hash(hash.into()), include_txs) } fn block_by_number(&self, num: BlockNumber, include_txs: bool) -> Result, Error> { - try!(self.active()); + self.active()?; self.block(num.into(), include_txs) } fn transaction_by_hash(&self, hash: RpcH256) -> Result, Error> { - try!(self.active()); + self.active()?; let hash: H256 = hash.into(); let miner = take_weak!(self.miner); let client = take_weak!(self.client); - Ok(try!(self.transaction(TransactionId::Hash(hash))).or_else(|| miner.transaction(client.chain_info().best_block_number, &hash).map(Into::into))) + Ok(self.transaction(TransactionId::Hash(hash))?.or_else(|| miner.transaction(client.chain_info().best_block_number, &hash).map(Into::into))) } fn transaction_by_block_hash_and_index(&self, hash: RpcH256, index: Index) -> Result, Error> { - try!(self.active()); + self.active()?; self.transaction(TransactionId::Location(BlockId::Hash(hash.into()), index.value())) } fn transaction_by_block_number_and_index(&self, num: BlockNumber, index: Index) -> Result, Error> { - try!(self.active()); + self.active()?; self.transaction(TransactionId::Location(num.into(), index.value())) } fn transaction_receipt(&self, hash: RpcH256) -> Result, Error> { - try!(self.active()); + self.active()?; let miner = take_weak!(self.miner); let best_block = take_weak!(self.client).chain_info().best_block_number; @@ -526,19 +525,19 @@ impl Eth for EthClient where } fn uncle_by_block_hash_and_index(&self, hash: RpcH256, index: Index) -> Result, Error> { - try!(self.active()); + self.active()?; self.uncle(UncleId { block: BlockId::Hash(hash.into()), position: index.value() }) } fn uncle_by_block_number_and_index(&self, num: BlockNumber, index: Index) -> Result, Error> { - try!(self.active()); + self.active()?; self.uncle(UncleId { block: num.into(), position: index.value() }) } fn compilers(&self) -> Result, Error> { - try!(self.active()); + self.active()?; let mut compilers = vec![]; if Command::new(SOLC).output().is_ok() { @@ -568,7 +567,7 @@ impl Eth for EthClient where } fn work(&self, no_new_work_timeout: Trailing) -> Result { - try!(self.active()); + self.active()?; let no_new_work_timeout = no_new_work_timeout.0; let client = take_weak!(self.client); @@ -620,7 +619,7 @@ impl Eth for EthClient where } fn submit_work(&self, nonce: RpcH64, pow_hash: RpcH256, mix_hash: RpcH256) -> Result { - try!(self.active()); + self.active()?; let nonce: H64 = nonce.into(); let pow_hash: H256 = pow_hash.into(); @@ -634,13 +633,13 @@ impl Eth for EthClient where } fn submit_hashrate(&self, rate: RpcU256, id: RpcH256) -> Result { - try!(self.active()); + self.active()?; self.external_miner.submit_hashrate(rate.into(), id.into()); Ok(true) } fn send_raw_transaction(&self, raw: Bytes) -> Result { - try!(self.active()); + self.active()?; let raw_transaction = raw.to_vec(); match UntrustedRlp::new(&raw_transaction).as_val() { @@ -654,10 +653,10 @@ impl Eth for EthClient where } fn call(&self, request: CallRequest, num: Trailing) -> Result { - try!(self.active()); + self.active()?; let request = CallRequest::into(request); - let signed = try!(self.sign_call(request)); + let signed = self.sign_call(request)?; let result = match num.0 { BlockNumber::Pending => take_weak!(self.miner).call(&*take_weak!(self.client), &signed, Default::default()), @@ -671,10 +670,10 @@ impl Eth for EthClient where } fn estimate_gas(&self, request: CallRequest, num: Trailing) -> Result { - try!(self.active()); + self.active()?; let request = CallRequest::into(request); - let signed = try!(self.sign_call(request)); + let signed = self.sign_call(request)?; let result = match num.0 { BlockNumber::Pending => take_weak!(self.miner).call(&*take_weak!(self.client), &signed, Default::default()), num => take_weak!(self.client).call(&signed, num.into(), Default::default()), @@ -686,19 +685,19 @@ impl Eth for EthClient where } fn compile_lll(&self, _: String) -> Result { - try!(self.active()); + self.active()?; rpc_unimplemented!() } fn compile_serpent(&self, _: String) -> Result { - try!(self.active()); + self.active()?; rpc_unimplemented!() } fn compile_solidity(&self, code: String) -> Result { - try!(self.active()); + self.active()?; let maybe_child = Command::new(SOLC) .arg("--bin") .arg("--optimize") @@ -710,11 +709,11 @@ impl Eth for EthClient where maybe_child .map_err(errors::compilation) .and_then(|mut child| { - try!(child.stdin.as_mut() + child.stdin.as_mut() .expect("we called child.stdin(Stdio::piped()) before spawn; qed") .write_all(code.as_bytes()) - .map_err(errors::compilation)); - let output = try!(child.wait_with_output().map_err(errors::compilation)); + .map_err(errors::compilation)?; + let output = child.wait_with_output().map_err(errors::compilation)?; let s = String::from_utf8_lossy(&output.stdout); if let Some(hex) = s.lines().skip_while(|ref l| !l.contains("Binary")).skip(1).next() { diff --git a/rpc/src/v1/impls/eth_filter.rs b/rpc/src/v1/impls/eth_filter.rs index 42e82a291..6d22d0b57 100644 --- a/rpc/src/v1/impls/eth_filter.rs +++ b/rpc/src/v1/impls/eth_filter.rs @@ -62,7 +62,7 @@ impl EthFilter for EthFilterClient where C: BlockChainClient + 'static, M: MinerService + 'static { fn new_filter(&self, filter: Filter) -> Result { - try!(self.active()); + self.active()?; let mut polls = self.polls.lock(); let block_number = take_weak!(self.client).chain_info().best_block_number; let id = polls.create_poll(PollFilter::Logs(block_number, Default::default(), filter)); @@ -70,7 +70,7 @@ impl EthFilter for EthFilterClient } fn new_block_filter(&self) -> Result { - try!(self.active()); + self.active()?; let mut polls = self.polls.lock(); let id = polls.create_poll(PollFilter::Block(take_weak!(self.client).chain_info().best_block_number)); @@ -78,7 +78,7 @@ impl EthFilter for EthFilterClient } fn new_pending_transaction_filter(&self) -> Result { - try!(self.active()); + self.active()?; let mut polls = self.polls.lock(); let best_block = take_weak!(self.client).chain_info().best_block_number; @@ -88,7 +88,7 @@ impl EthFilter for EthFilterClient } fn filter_changes(&self, index: Index) -> Result { - try!(self.active()); + self.active()?; let client = take_weak!(self.client); let mut polls = self.polls.lock(); match polls.poll_mut(&index.value()) { @@ -180,7 +180,7 @@ impl EthFilter for EthFilterClient } fn filter_logs(&self, index: Index) -> Result, Error> { - try!(self.active()); + self.active()?; let mut polls = self.polls.lock(); match polls.poll(&index.value()) { @@ -207,7 +207,7 @@ impl EthFilter for EthFilterClient } fn uninstall_filter(&self, index: Index) -> Result { - try!(self.active()); + self.active()?; self.polls.lock().remove_poll(&index.value()); Ok(true) diff --git a/rpc/src/v1/impls/parity.rs b/rpc/src/v1/impls/parity.rs index 33d1dfaca..f6dc30517 100644 --- a/rpc/src/v1/impls/parity.rs +++ b/rpc/src/v1/impls/parity.rs @@ -114,18 +114,18 @@ impl Parity for ParityClient where U: UpdateService + 'static, { fn accounts_info(&self, dapp: Trailing) -> Result>, Error> { - try!(self.active()); + self.active()?; let dapp = dapp.0; let store = take_weak!(self.accounts); - let dapp_accounts = try!(store + let dapp_accounts = store .note_dapp_used(dapp.clone().into()) .and_then(|_| store.dapps_addresses(dapp.into())) - .map_err(|e| errors::internal("Could not fetch accounts.", e)) - ).into_iter().collect::>(); + .map_err(|e| errors::internal("Could not fetch accounts.", e))? + .into_iter().collect::>(); - let info = try!(store.accounts_info().map_err(|e| errors::account("Could not fetch account info.", e))); + let info = store.accounts_info().map_err(|e| errors::account("Could not fetch account info.", e))?; let other = store.addresses_info().expect("addresses_info always returns Ok; qed"); Ok(info @@ -143,56 +143,56 @@ impl Parity for ParityClient where } fn transactions_limit(&self) -> Result { - try!(self.active()); + self.active()?; Ok(take_weak!(self.miner).transactions_limit()) } fn min_gas_price(&self) -> Result { - try!(self.active()); + self.active()?; Ok(U256::from(take_weak!(self.miner).minimal_gas_price())) } fn extra_data(&self) -> Result { - try!(self.active()); + self.active()?; Ok(Bytes::new(take_weak!(self.miner).extra_data())) } fn gas_floor_target(&self) -> Result { - try!(self.active()); + self.active()?; Ok(U256::from(take_weak!(self.miner).gas_floor_target())) } fn gas_ceil_target(&self) -> Result { - try!(self.active()); + self.active()?; Ok(U256::from(take_weak!(self.miner).gas_ceil_target())) } fn dev_logs(&self) -> Result, Error> { - try!(self.active()); + self.active()?; let logs = self.logger.logs(); Ok(logs.as_slice().to_owned()) } fn dev_logs_levels(&self) -> Result { - try!(self.active()); + self.active()?; Ok(self.logger.levels().to_owned()) } fn net_chain(&self) -> Result { - try!(self.active()); + self.active()?; Ok(self.settings.chain.clone()) } fn net_peers(&self) -> Result { - try!(self.active()); + self.active()?; let sync = take_weak!(self.sync); let sync_status = sync.status(); @@ -208,19 +208,19 @@ impl Parity for ParityClient where } fn net_port(&self) -> Result { - try!(self.active()); + self.active()?; Ok(self.settings.network_port) } fn node_name(&self) -> Result { - try!(self.active()); + self.active()?; Ok(self.settings.name.clone()) } fn registry_address(&self) -> Result, Error> { - try!(self.active()); + self.active()?; Ok( take_weak!(self.client) @@ -232,7 +232,7 @@ impl Parity for ParityClient where } fn rpc_settings(&self) -> Result { - try!(self.active()); + self.active()?; Ok(RpcSettings { enabled: self.settings.rpc_enabled, interface: self.settings.rpc_interface.clone(), @@ -241,18 +241,18 @@ impl Parity for ParityClient where } fn default_extra_data(&self) -> Result { - try!(self.active()); + self.active()?; Ok(Bytes::new(version_data())) } fn gas_price_histogram(&self) -> Result { - try!(self.active()); + self.active()?; take_weak!(self.client).gas_price_histogram(100, 10).ok_or_else(errors::not_enough_data).map(Into::into) } fn unsigned_transactions_count(&self) -> Result { - try!(self.active()); + self.active()?; match self.signer { None => Err(errors::signer_disabled()), @@ -261,19 +261,19 @@ impl Parity for ParityClient where } fn generate_secret_phrase(&self) -> Result { - try!(self.active()); + self.active()?; Ok(random_phrase(12)) } fn phrase_to_address(&self, phrase: String) -> Result { - try!(self.active()); + self.active()?; Ok(Brain::new(phrase).generate().unwrap().address().into()) } fn list_accounts(&self, count: u64, after: Option, block_number: Trailing) -> Result>, Error> { - try!(self.active()); + self.active()?; Ok(take_weak!(self.client) .list_accounts(block_number.0.into(), after.map(Into::into).as_ref(), count) @@ -281,7 +281,7 @@ impl Parity for ParityClient where } fn list_storage_keys(&self, address: H160, count: u64, after: Option, block_number: Trailing) -> Result>, Error> { - try!(self.active()); + self.active()?; Ok(take_weak!(self.client) .list_storage(block_number.0.into(), &address.into(), after.map(Into::into).as_ref(), count) @@ -289,7 +289,7 @@ impl Parity for ParityClient where } fn encrypt_message(&self, key: H512, phrase: Bytes) -> Result { - try!(self.active()); + self.active()?; ecies::encrypt(&key.into(), &DEFAULT_MAC, &phrase.0) .map_err(errors::encryption_error) @@ -297,19 +297,19 @@ impl Parity for ParityClient where } fn pending_transactions(&self) -> Result, Error> { - try!(self.active()); + self.active()?; Ok(take_weak!(self.miner).pending_transactions().into_iter().map(Into::into).collect::>()) } fn future_transactions(&self) -> Result, Error> { - try!(self.active()); + self.active()?; Ok(take_weak!(self.miner).future_transactions().into_iter().map(Into::into).collect::>()) } fn pending_transactions_stats(&self) -> Result, Error> { - try!(self.active()); + self.active()?; let stats = take_weak!(self.sync).transactions_stats(); Ok(stats.into_iter() @@ -319,7 +319,7 @@ impl Parity for ParityClient where } fn local_transactions(&self) -> Result, Error> { - try!(self.active()); + self.active()?; let transactions = take_weak!(self.miner).local_transactions(); Ok(transactions @@ -330,7 +330,7 @@ impl Parity for ParityClient where } fn signer_port(&self) -> Result { - try!(self.active()); + self.active()?; self.signer .clone() @@ -340,21 +340,21 @@ impl Parity for ParityClient where } fn dapps_port(&self) -> Result { - try!(self.active()); + self.active()?; self.dapps_port .ok_or_else(|| errors::dapps_disabled()) } fn dapps_interface(&self) -> Result { - try!(self.active()); + self.active()?; self.dapps_interface.clone() .ok_or_else(|| errors::dapps_disabled()) } fn next_nonce(&self, address: H160) -> Result { - try!(self.active()); + self.active()?; let address: Address = address.into(); let miner = take_weak!(self.miner); let client = take_weak!(self.client); @@ -380,25 +380,25 @@ impl Parity for ParityClient where } fn consensus_capability(&self) -> Result { - try!(self.active()); + self.active()?; let updater = take_weak!(self.updater); Ok(updater.capability().into()) } fn version_info(&self) -> Result { - try!(self.active()); + self.active()?; let updater = take_weak!(self.updater); Ok(updater.version_info().into()) } fn releases_info(&self) -> Result, Error> { - try!(self.active()); + self.active()?; let updater = take_weak!(self.updater); Ok(updater.info().map(Into::into)) } fn chain_status(&self) -> Result { - try!(self.active()); + self.active()?; let chain_info = take_weak!(self.client).chain_info(); diff --git a/rpc/src/v1/impls/parity_accounts.rs b/rpc/src/v1/impls/parity_accounts.rs index 3f3464528..fa1f776b5 100644 --- a/rpc/src/v1/impls/parity_accounts.rs +++ b/rpc/src/v1/impls/parity_accounts.rs @@ -52,9 +52,9 @@ impl ParityAccountsClient where C: MiningBlockChainClient { impl ParityAccounts for ParityAccountsClient where C: MiningBlockChainClient { fn all_accounts_info(&self) -> Result>, Error> { - try!(self.active()); + self.active()?; let store = take_weak!(self.accounts); - let info = try!(store.accounts_info().map_err(|e| errors::account("Could not fetch account info.", e))); + let info = store.accounts_info().map_err(|e| errors::account("Could not fetch account info.", e))?; let other = store.addresses_info().expect("addresses_info always returns Ok; qed"); Ok(info.into_iter().chain(other.into_iter()).map(|(a, v)| { @@ -70,7 +70,7 @@ impl ParityAccounts for ParityAccountsClient where C: MiningBlock } fn new_account_from_phrase(&self, phrase: String, pass: String) -> Result { - try!(self.active()); + self.active()?; let store = take_weak!(self.accounts); store.insert_account(*Brain::new(phrase).generate().unwrap().secret(), &pass) @@ -79,7 +79,7 @@ impl ParityAccounts for ParityAccountsClient where C: MiningBlock } fn new_account_from_wallet(&self, json: String, pass: String) -> Result { - try!(self.active()); + self.active()?; let store = take_weak!(self.accounts); store.import_presale(json.as_bytes(), &pass) @@ -89,7 +89,7 @@ impl ParityAccounts for ParityAccountsClient where C: MiningBlock } fn new_account_from_secret(&self, secret: RpcH256, pass: String) -> Result { - try!(self.active()); + self.active()?; let store = take_weak!(self.accounts); store.insert_account(secret.into(), &pass) @@ -98,7 +98,7 @@ impl ParityAccounts for ParityAccountsClient where C: MiningBlock } fn test_password(&self, account: RpcH160, password: String) -> Result { - try!(self.active()); + self.active()?; let account: Address = account.into(); take_weak!(self.accounts) @@ -107,7 +107,7 @@ impl ParityAccounts for ParityAccountsClient where C: MiningBlock } fn change_password(&self, account: RpcH160, password: String, new_password: String) -> Result { - try!(self.active()); + self.active()?; let account: Address = account.into(); take_weak!(self.accounts) .change_password(&account, password, new_password) @@ -116,7 +116,7 @@ impl ParityAccounts for ParityAccountsClient where C: MiningBlock } fn kill_account(&self, account: RpcH160, password: String) -> Result { - try!(self.active()); + self.active()?; let account: Address = account.into(); take_weak!(self.accounts) .kill_account(&account, &password) @@ -125,7 +125,7 @@ impl ParityAccounts for ParityAccountsClient where C: MiningBlock } fn remove_address(&self, addr: RpcH160) -> Result { - try!(self.active()); + self.active()?; let store = take_weak!(self.accounts); let addr: Address = addr.into(); @@ -135,7 +135,7 @@ impl ParityAccounts for ParityAccountsClient where C: MiningBlock } fn set_account_name(&self, addr: RpcH160, name: String) -> Result { - try!(self.active()); + self.active()?; let store = take_weak!(self.accounts); let addr: Address = addr.into(); @@ -146,7 +146,7 @@ impl ParityAccounts for ParityAccountsClient where C: MiningBlock } fn set_account_meta(&self, addr: RpcH160, meta: String) -> Result { - try!(self.active()); + self.active()?; let store = take_weak!(self.accounts); let addr: Address = addr.into(); @@ -211,7 +211,7 @@ impl ParityAccounts for ParityAccountsClient where C: MiningBlock } fn geth_accounts(&self) -> Result, Error> { - try!(self.active()); + self.active()?; let store = take_weak!(self.accounts); Ok(into_vec(store.list_geth_accounts(false))) diff --git a/rpc/src/v1/impls/parity_set.rs b/rpc/src/v1/impls/parity_set.rs index 6af40a389..e0f9bca53 100644 --- a/rpc/src/v1/impls/parity_set.rs +++ b/rpc/src/v1/impls/parity_set.rs @@ -82,62 +82,62 @@ impl ParitySet for ParitySetClient where { fn set_min_gas_price(&self, gas_price: U256) -> Result { - try!(self.active()); + self.active()?; take_weak!(self.miner).set_minimal_gas_price(gas_price.into()); Ok(true) } fn set_gas_floor_target(&self, target: U256) -> Result { - try!(self.active()); + self.active()?; take_weak!(self.miner).set_gas_floor_target(target.into()); Ok(true) } fn set_gas_ceil_target(&self, target: U256) -> Result { - try!(self.active()); + self.active()?; take_weak!(self.miner).set_gas_ceil_target(target.into()); Ok(true) } fn set_extra_data(&self, extra_data: Bytes) -> Result { - try!(self.active()); + self.active()?; take_weak!(self.miner).set_extra_data(extra_data.to_vec()); Ok(true) } fn set_author(&self, author: H160) -> Result { - try!(self.active()); + self.active()?; take_weak!(self.miner).set_author(author.into()); Ok(true) } fn set_engine_signer(&self, address: H160, password: String) -> Result { - try!(self.active()); - try!(take_weak!(self.miner).set_engine_signer(address.into(), password).map_err(Into::into).map_err(errors::from_password_error)); + self.active()?; + take_weak!(self.miner).set_engine_signer(address.into(), password).map_err(Into::into).map_err(errors::from_password_error)?; Ok(true) } fn set_transactions_limit(&self, limit: usize) -> Result { - try!(self.active()); + self.active()?; take_weak!(self.miner).set_transactions_limit(limit); Ok(true) } fn set_tx_gas_limit(&self, limit: U256) -> Result { - try!(self.active()); + self.active()?; take_weak!(self.miner).set_tx_gas_limit(limit.into()); Ok(true) } fn add_reserved_peer(&self, peer: String) -> Result { - try!(self.active()); + self.active()?; match take_weak!(self.net).add_reserved_peer(peer) { Ok(()) => Ok(true), @@ -146,7 +146,7 @@ impl ParitySet for ParitySetClient where } fn remove_reserved_peer(&self, peer: String) -> Result { - try!(self.active()); + self.active()?; match take_weak!(self.net).remove_reserved_peer(peer) { Ok(()) => Ok(true), @@ -155,14 +155,14 @@ impl ParitySet for ParitySetClient where } fn drop_non_reserved_peers(&self) -> Result { - try!(self.active()); + self.active()?; take_weak!(self.net).deny_unreserved_peers(); Ok(true) } fn accept_non_reserved_peers(&self) -> Result { - try!(self.active()); + self.active()?; take_weak!(self.net).accept_unreserved_peers(); Ok(true) @@ -214,13 +214,13 @@ impl ParitySet for ParitySetClient where } fn upgrade_ready(&self) -> Result, Error> { - try!(self.active()); + self.active()?; let updater = take_weak!(self.updater); Ok(updater.upgrade_ready().map(Into::into)) } fn execute_upgrade(&self) -> Result { - try!(self.active()); + self.active()?; let updater = take_weak!(self.updater); Ok(updater.execute_upgrade()) } diff --git a/rpc/src/v1/impls/personal.rs b/rpc/src/v1/impls/personal.rs index d1cdd9810..5033c06e0 100644 --- a/rpc/src/v1/impls/personal.rs +++ b/rpc/src/v1/impls/personal.rs @@ -56,15 +56,15 @@ impl PersonalClient where C: MiningBlockChainClient, M: MinerService impl Personal for PersonalClient where C: MiningBlockChainClient, M: MinerService { fn accounts(&self) -> Result, Error> { - try!(self.active()); + self.active()?; let store = take_weak!(self.accounts); - let accounts = try!(store.accounts().map_err(|e| errors::account("Could not fetch accounts.", e))); + let accounts = store.accounts().map_err(|e| errors::account("Could not fetch accounts.", e))?; Ok(accounts.into_iter().map(Into::into).collect::>()) } fn new_account(&self, pass: String) -> Result { - try!(self.active()); + self.active()?; let store = take_weak!(self.accounts); store.new_account(&pass) @@ -73,7 +73,7 @@ impl Personal for PersonalClient where C: MiningBl } fn unlock_account(&self, account: RpcH160, account_pass: String, duration: Option) -> Result { - try!(self.active()); + self.active()?; let account: Address = account.into(); let store = take_weak!(self.accounts); let duration = match duration { @@ -103,7 +103,7 @@ impl Personal for PersonalClient where C: MiningBl } fn sign_and_send_transaction(&self, request: TransactionRequest, password: String) -> Result { - try!(self.active()); + self.active()?; let client = take_weak!(self.client); let miner = take_weak!(self.miner); let accounts = take_weak!(self.accounts); diff --git a/rpc/src/v1/impls/signer.rs b/rpc/src/v1/impls/signer.rs index 821c04928..90b627569 100644 --- a/rpc/src/v1/impls/signer.rs +++ b/rpc/src/v1/impls/signer.rs @@ -64,7 +64,7 @@ impl SignerClient where C: MiningBlockChainClient, fn confirm_internal(&self, id: U256, modification: TransactionModification, f: F) -> Result, Error> where F: FnOnce(&C, &M, &AccountProvider, ConfirmationPayload) -> Result, Error>, { - try!(self.active()); + self.active()?; let id = id.into(); let accounts = take_weak!(self.accounts); @@ -99,7 +99,7 @@ impl SignerClient where C: MiningBlockChainClient, impl Signer for SignerClient where C: MiningBlockChainClient, M: MinerService { fn requests_to_confirm(&self) -> Result, Error> { - try!(self.active()); + self.active()?; let signer = take_weak!(self.signer); Ok(signer.requests() @@ -130,7 +130,7 @@ impl Signer for SignerClient where C: MiningBlockC } fn confirm_request_raw(&self, id: U256, bytes: Bytes) -> Result { - try!(self.active()); + self.active()?; let id = id.into(); let signer = take_weak!(self.signer); @@ -140,12 +140,8 @@ impl Signer for SignerClient where C: MiningBlockC signer.peek(&id).map(|confirmation| { let result = match confirmation.payload { ConfirmationPayload::SendTransaction(request) => { - let signed_transaction: SignedTransaction = try!( - UntrustedRlp::new(&bytes.0).as_val().map_err(errors::from_rlp_error) - ); - let sender = try!( - signed_transaction.sender().map_err(|e| errors::invalid_params("Invalid signature.", e)) - ); + let signed_transaction: SignedTransaction = UntrustedRlp::new(&bytes.0).as_val().map_err(errors::from_rlp_error)?; + let sender = signed_transaction.sender().map_err(|e| errors::invalid_params("Invalid signature.", e))?; // Verification let sender_matches = sender == request.from; @@ -185,7 +181,7 @@ impl Signer for SignerClient where C: MiningBlockC } fn reject_request(&self, id: U256) -> Result { - try!(self.active()); + self.active()?; let signer = take_weak!(self.signer); let res = signer.request_rejected(id.into()); @@ -193,7 +189,7 @@ impl Signer for SignerClient where C: MiningBlockC } fn generate_token(&self) -> Result { - try!(self.active()); + self.active()?; let signer = take_weak!(self.signer); signer.generate_token() diff --git a/rpc/src/v1/impls/signing.rs b/rpc/src/v1/impls/signing.rs index cc2c74fcc..bd3f1ec3f 100644 --- a/rpc/src/v1/impls/signing.rs +++ b/rpc/src/v1/impls/signing.rs @@ -123,7 +123,7 @@ impl ParitySigning for SigningQueueClient where M: MinerService, { fn post_sign(&self, address: RpcH160, hash: RpcH256) -> Result, Error> { - try!(self.active()); + self.active()?; self.dispatch(RpcConfirmationPayload::Signature((address, hash).into())) .map(|result| match result { DispatchResult::Value(v) => RpcEither::Or(v), @@ -136,7 +136,7 @@ impl ParitySigning for SigningQueueClient where } fn post_transaction(&self, request: RpcTransactionRequest) -> Result, Error> { - try!(self.active()); + self.active()?; self.dispatch(RpcConfirmationPayload::SendTransaction(request)) .map(|result| match result { DispatchResult::Value(v) => RpcEither::Or(v), @@ -149,7 +149,7 @@ impl ParitySigning for SigningQueueClient where } fn check_request(&self, id: RpcU256) -> Result, Error> { - try!(self.active()); + self.active()?; let mut pending = self.pending.lock(); let id: U256 = id.into(); let res = match pending.get(&id) { diff --git a/rpc/src/v1/impls/signing_unsafe.rs b/rpc/src/v1/impls/signing_unsafe.rs index 9ad5828f2..d64281bc9 100644 --- a/rpc/src/v1/impls/signing_unsafe.rs +++ b/rpc/src/v1/impls/signing_unsafe.rs @@ -70,7 +70,7 @@ impl SigningUnsafeClient where } fn handle(&self, payload: RpcConfirmationPayload) -> Result { - try!(self.active()); + self.active()?; let client = take_weak!(self.client); let miner = take_weak!(self.miner); let accounts = take_weak!(self.accounts); diff --git a/rpc/src/v1/impls/traces.rs b/rpc/src/v1/impls/traces.rs index 5f42c0cf3..21f81cc16 100644 --- a/rpc/src/v1/impls/traces.rs +++ b/rpc/src/v1/impls/traces.rs @@ -76,7 +76,7 @@ impl TracesClient where C: BlockChainClient, M: MinerService { impl Traces for TracesClient where C: BlockChainClient + 'static, M: MinerService + 'static { fn filter(&self, filter: TraceFilter) -> Result, Error> { - try!(self.active()); + self.active()?; let client = take_weak!(self.client); let traces = client.filter_traces(filter.into()); @@ -85,7 +85,7 @@ impl Traces for TracesClient where C: BlockChainClient + 'static, M: } fn block_traces(&self, block_number: BlockNumber) -> Result, Error> { - try!(self.active()); + self.active()?; let client = take_weak!(self.client); let traces = client.block_traces(block_number.into()); let traces = traces.map_or_else(Vec::new, |traces| traces.into_iter().map(LocalizedTrace::from).collect()); @@ -93,7 +93,7 @@ impl Traces for TracesClient where C: BlockChainClient + 'static, M: } fn transaction_traces(&self, transaction_hash: H256) -> Result, Error> { - try!(self.active()); + self.active()?; let client = take_weak!(self.client); let traces = client.transaction_traces(TransactionId::Hash(transaction_hash.into())); @@ -102,7 +102,7 @@ impl Traces for TracesClient where C: BlockChainClient + 'static, M: } fn trace(&self, transaction_hash: H256, address: Vec) -> Result, Error> { - try!(self.active()); + self.active()?; let client = take_weak!(self.client); let id = TraceId { transaction: TransactionId::Hash(transaction_hash.into()), @@ -115,11 +115,11 @@ impl Traces for TracesClient where C: BlockChainClient + 'static, M: } fn call(&self, request: CallRequest, flags: Vec, block: Trailing) -> Result, Error> { - try!(self.active()); + self.active()?; let block = block.0; let request = CallRequest::into(request); - let signed = try!(self.sign_call(request)); + let signed = self.sign_call(request)?; Ok(match take_weak!(self.client).call(&signed, block.into(), to_call_analytics(flags)) { Ok(e) => Some(TraceResults::from(e)), _ => None, @@ -127,7 +127,7 @@ impl Traces for TracesClient where C: BlockChainClient + 'static, M: } fn raw_transaction(&self, raw_transaction: Bytes, flags: Vec, block: Trailing) -> Result, Error> { - try!(self.active()); + self.active()?; let block = block.0; let raw_transaction = Bytes::to_vec(raw_transaction); @@ -141,7 +141,7 @@ impl Traces for TracesClient where C: BlockChainClient + 'static, M: } fn replay_transaction(&self, transaction_hash: H256, flags: Vec) -> Result, Error> { - try!(self.active()); + self.active()?; Ok(match take_weak!(self.client).replay(TransactionId::Hash(transaction_hash.into()), to_call_analytics(flags)) { Ok(e) => Some(TraceResults::from(e)), diff --git a/rpc/src/v1/types/block.rs b/rpc/src/v1/types/block.rs index 680cbd562..a9ad09a04 100644 --- a/rpc/src/v1/types/block.rs +++ b/rpc/src/v1/types/block.rs @@ -122,7 +122,7 @@ impl Serialize for RichBlock { // join two objects block.extend(extras); // and serialize - try!(block.serialize(serializer)); + block.serialize(serializer)?; } Ok(()) } diff --git a/rpc/src/v1/types/bytes.rs b/rpc/src/v1/types/bytes.rs index d9a346836..56d80ad1a 100644 --- a/rpc/src/v1/types/bytes.rs +++ b/rpc/src/v1/types/bytes.rs @@ -77,7 +77,7 @@ impl Visitor for BytesVisitor { ); Ok(Bytes::new(Vec::new())) } else if value.len() >= 2 && &value[0..2] == "0x" && value.len() & 1 == 0 { - Ok(Bytes::new(try!(FromHex::from_hex(&value[2..]).map_err(|_| Error::custom("invalid hex"))))) + Ok(Bytes::new(FromHex::from_hex(&value[2..]).map_err(|_| Error::custom("invalid hex"))?)) } else { Err(Error::custom("invalid format")) } diff --git a/rpc/src/v1/types/filter.rs b/rpc/src/v1/types/filter.rs index 6ef57b7a7..9ada15ba3 100644 --- a/rpc/src/v1/types/filter.rs +++ b/rpc/src/v1/types/filter.rs @@ -35,7 +35,7 @@ pub enum VariadicValue where T: Deserialize { impl Deserialize for VariadicValue where T: Deserialize { fn deserialize(deserializer: &mut D) -> Result, D::Error> where D: Deserializer { - let v = try!(Value::deserialize(deserializer)); + let v = Value::deserialize(deserializer)?; if v.is_null() { return Ok(VariadicValue::Null); diff --git a/rpc/src/v1/types/trace.rs b/rpc/src/v1/types/trace.rs index 5ba166010..f823131b5 100644 --- a/rpc/src/v1/types/trace.rs +++ b/rpc/src/v1/types/trace.rs @@ -431,36 +431,36 @@ impl Serialize for LocalizedTrace { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer { - let mut state = try!(serializer.serialize_struct("LocalizedTrace", 9)); + let mut state = serializer.serialize_struct("LocalizedTrace", 9)?; match self.action { Action::Call(ref call) => { - try!(serializer.serialize_struct_elt(&mut state, "type", "call")); - try!(serializer.serialize_struct_elt(&mut state, "action", call)); + serializer.serialize_struct_elt(&mut state, "type", "call")?; + serializer.serialize_struct_elt(&mut state, "action", call)?; }, Action::Create(ref create) => { - try!(serializer.serialize_struct_elt(&mut state, "type", "create")); - try!(serializer.serialize_struct_elt(&mut state, "action", create)); + serializer.serialize_struct_elt(&mut state, "type", "create")?; + serializer.serialize_struct_elt(&mut state, "action", create)?; }, Action::Suicide(ref suicide) => { - try!(serializer.serialize_struct_elt(&mut state, "type", "suicide")); - try!(serializer.serialize_struct_elt(&mut state, "action", suicide)); + serializer.serialize_struct_elt(&mut state, "type", "suicide")?; + serializer.serialize_struct_elt(&mut state, "action", suicide)?; }, } match self.result { - Res::Call(ref call) => try!(serializer.serialize_struct_elt(&mut state, "result", call)), - Res::Create(ref create) => try!(serializer.serialize_struct_elt(&mut state, "result", create)), - Res::FailedCall(ref error) => try!(serializer.serialize_struct_elt(&mut state, "error", error.to_string())), - Res::FailedCreate(ref error) => try!(serializer.serialize_struct_elt(&mut state, "error", error.to_string())), - Res::None => try!(serializer.serialize_struct_elt(&mut state, "result", None as Option)), + Res::Call(ref call) => serializer.serialize_struct_elt(&mut state, "result", call)?, + Res::Create(ref create) => serializer.serialize_struct_elt(&mut state, "result", create)?, + Res::FailedCall(ref error) => serializer.serialize_struct_elt(&mut state, "error", error.to_string())?, + Res::FailedCreate(ref error) => serializer.serialize_struct_elt(&mut state, "error", error.to_string())?, + Res::None => serializer.serialize_struct_elt(&mut state, "result", None as Option)?, } - try!(serializer.serialize_struct_elt(&mut state, "traceAddress", &self.trace_address)); - try!(serializer.serialize_struct_elt(&mut state, "subtraces", &self.subtraces)); - try!(serializer.serialize_struct_elt(&mut state, "transactionPosition", &self.transaction_position)); - try!(serializer.serialize_struct_elt(&mut state, "transactionHash", &self.transaction_hash)); - try!(serializer.serialize_struct_elt(&mut state, "blockNumber", &self.block_number)); - try!(serializer.serialize_struct_elt(&mut state, "blockHash", &self.block_hash)); + serializer.serialize_struct_elt(&mut state, "traceAddress", &self.trace_address)?; + serializer.serialize_struct_elt(&mut state, "subtraces", &self.subtraces)?; + serializer.serialize_struct_elt(&mut state, "transactionPosition", &self.transaction_position)?; + serializer.serialize_struct_elt(&mut state, "transactionHash", &self.transaction_hash)?; + serializer.serialize_struct_elt(&mut state, "blockNumber", &self.block_number)?; + serializer.serialize_struct_elt(&mut state, "blockHash", &self.block_hash)?; serializer.serialize_struct_end(state) } @@ -498,32 +498,32 @@ impl Serialize for Trace { fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer { - let mut state = try!(serializer.serialize_struct("Trace", 4)); + let mut state = serializer.serialize_struct("Trace", 4)?; match self.action { Action::Call(ref call) => { - try!(serializer.serialize_struct_elt(&mut state, "type", "call")); - try!(serializer.serialize_struct_elt(&mut state, "action", call)); + serializer.serialize_struct_elt(&mut state, "type", "call")?; + serializer.serialize_struct_elt(&mut state, "action", call)?; }, Action::Create(ref create) => { - try!(serializer.serialize_struct_elt(&mut state, "type", "create")); - try!(serializer.serialize_struct_elt(&mut state, "action", create)); + serializer.serialize_struct_elt(&mut state, "type", "create")?; + serializer.serialize_struct_elt(&mut state, "action", create)?; }, Action::Suicide(ref suicide) => { - try!(serializer.serialize_struct_elt(&mut state, "type", "suicide")); - try!(serializer.serialize_struct_elt(&mut state, "action", suicide)); + serializer.serialize_struct_elt(&mut state, "type", "suicide")?; + serializer.serialize_struct_elt(&mut state, "action", suicide)?; }, } match self.result { - Res::Call(ref call) => try!(serializer.serialize_struct_elt(&mut state, "result", call)), - Res::Create(ref create) => try!(serializer.serialize_struct_elt(&mut state, "result", create)), - Res::FailedCall(ref error) => try!(serializer.serialize_struct_elt(&mut state, "error", error.to_string())), - Res::FailedCreate(ref error) => try!(serializer.serialize_struct_elt(&mut state, "error", error.to_string())), - Res::None => try!(serializer.serialize_struct_elt(&mut state, "result", None as Option)), + Res::Call(ref call) => serializer.serialize_struct_elt(&mut state, "result", call)?, + Res::Create(ref create) => serializer.serialize_struct_elt(&mut state, "result", create)?, + Res::FailedCall(ref error) => serializer.serialize_struct_elt(&mut state, "error", error.to_string())?, + Res::FailedCreate(ref error) => serializer.serialize_struct_elt(&mut state, "error", error.to_string())?, + Res::None => serializer.serialize_struct_elt(&mut state, "result", None as Option)?, } - try!(serializer.serialize_struct_elt(&mut state, "traceAddress", &self.trace_address)); - try!(serializer.serialize_struct_elt(&mut state, "subtraces", &self.subtraces)); + serializer.serialize_struct_elt(&mut state, "traceAddress", &self.trace_address)?; + serializer.serialize_struct_elt(&mut state, "subtraces", &self.subtraces)?; serializer.serialize_struct_end(state) } diff --git a/rpc/src/v1/types/transaction.rs b/rpc/src/v1/types/transaction.rs index 0db614887..57c29a3b4 100644 --- a/rpc/src/v1/types/transaction.rs +++ b/rpc/src/v1/types/transaction.rs @@ -109,32 +109,32 @@ impl Serialize for LocalTransactionStatus { let status = "status"; let transaction = "transaction"; - let mut state = try!(serializer.serialize_struct("LocalTransactionStatus", elems)); + let mut state = serializer.serialize_struct("LocalTransactionStatus", elems)?; match *self { - Pending => try!(serializer.serialize_struct_elt(&mut state, status, "pending")), - Future => try!(serializer.serialize_struct_elt(&mut state, status, "future")), + Pending => serializer.serialize_struct_elt(&mut state, status, "pending")?, + Future => serializer.serialize_struct_elt(&mut state, status, "future")?, Mined(ref tx) => { - try!(serializer.serialize_struct_elt(&mut state, status, "mined")); - try!(serializer.serialize_struct_elt(&mut state, transaction, tx)); + serializer.serialize_struct_elt(&mut state, status, "mined")?; + serializer.serialize_struct_elt(&mut state, transaction, tx)?; }, Dropped(ref tx) => { - try!(serializer.serialize_struct_elt(&mut state, status, "dropped")); - try!(serializer.serialize_struct_elt(&mut state, transaction, tx)); + serializer.serialize_struct_elt(&mut state, status, "dropped")?; + serializer.serialize_struct_elt(&mut state, transaction, tx)?; }, Invalid(ref tx) => { - try!(serializer.serialize_struct_elt(&mut state, status, "invalid")); - try!(serializer.serialize_struct_elt(&mut state, transaction, tx)); + serializer.serialize_struct_elt(&mut state, status, "invalid")?; + serializer.serialize_struct_elt(&mut state, transaction, tx)?; }, Rejected(ref tx, ref reason) => { - try!(serializer.serialize_struct_elt(&mut state, status, "rejected")); - try!(serializer.serialize_struct_elt(&mut state, transaction, tx)); - try!(serializer.serialize_struct_elt(&mut state, "error", reason)); + serializer.serialize_struct_elt(&mut state, status, "rejected")?; + serializer.serialize_struct_elt(&mut state, transaction, tx)?; + serializer.serialize_struct_elt(&mut state, "error", reason)?; }, Replaced(ref tx, ref gas_price, ref hash) => { - try!(serializer.serialize_struct_elt(&mut state, status, "replaced")); - try!(serializer.serialize_struct_elt(&mut state, transaction, tx)); - try!(serializer.serialize_struct_elt(&mut state, "hash", hash)); - try!(serializer.serialize_struct_elt(&mut state, "gasPrice", gas_price)); + serializer.serialize_struct_elt(&mut state, status, "replaced")?; + serializer.serialize_struct_elt(&mut state, transaction, tx)?; + serializer.serialize_struct_elt(&mut state, "hash", hash)?; + serializer.serialize_struct_elt(&mut state, "gasPrice", gas_price)?; }, } serializer.serialize_struct_end(state) diff --git a/rpc_cli/src/lib.rs b/rpc_cli/src/lib.rs index c79e4cc26..0cfb54353 100644 --- a/rpc_cli/src/lib.rs +++ b/rpc_cli/src/lib.rs @@ -46,7 +46,7 @@ fn sign_transactions( signer: &mut SignerRpc, password: String ) -> Result { - try!(signer.requests_to_confirm().map(|reqs| { + signer.requests_to_confirm().map(|reqs| { match reqs { Ok(ref reqs) if reqs.is_empty() => { Ok("No transactions in signing queue".to_owned()) @@ -63,11 +63,11 @@ fn sign_transactions( } }).map_err(|err| { format!("{:?}", err) - }).wait()) + }).wait()? } fn list_transactions(signer: &mut SignerRpc) -> Result { - try!(signer.requests_to_confirm().map(|reqs| { + signer.requests_to_confirm().map(|reqs| { match reqs { Ok(ref reqs) if reqs.is_empty() => { Ok("No transactions in signing queue".to_owned()) @@ -85,26 +85,26 @@ fn list_transactions(signer: &mut SignerRpc) -> Result { } }).map_err(|err| { format!("{:?}", err) - }).wait()) + }).wait()? } fn sign_transaction( signer: &mut SignerRpc, id: U256, password: &str ) -> Result { - try!(signer.confirm_request(id, None, None, None, password).map(|res| { + signer.confirm_request(id, None, None, None, password).map(|res| { match res { Ok(u) => Ok(format!("Signed transaction id: {:#x}", u)), Err(e) => Err(format!("{:?}", e)), } }).map_err(|err| { format!("{:?}", err) - }).wait()) + }).wait()? } fn reject_transaction( signer: &mut SignerRpc, id: U256) -> Result { - try!(signer.reject_request(id).map(|res| { + signer.reject_request(id).map(|res| { match res { Ok(true) => Ok(format!("Rejected transaction id {:#x}", id)), Ok(false) => Err(format!("No such request")), @@ -112,7 +112,7 @@ fn reject_transaction( } }).map_err(|err| { format!("{:?}", err) - }).wait()) + }).wait()? } // cmds @@ -121,20 +121,20 @@ pub fn signer_list( signerport: u16, authfile: PathBuf ) -> Result { let addr = &format!("ws://127.0.0.1:{}", signerport); - let mut signer = try!(SignerRpc::new(addr, &authfile).map_err(|err| { + let mut signer = SignerRpc::new(addr, &authfile).map_err(|err| { format!("{:?}", err) - })); + })?; list_transactions(&mut signer) } pub fn signer_reject( id: Option, signerport: u16, authfile: PathBuf ) -> Result { - let id = try!(id.ok_or(format!("id required for signer reject"))); + let id = id.ok_or(format!("id required for signer reject"))?; let addr = &format!("ws://127.0.0.1:{}", signerport); - let mut signer = try!(SignerRpc::new(addr, &authfile).map_err(|err| { + let mut signer = SignerRpc::new(addr, &authfile).map_err(|err| { format!("{:?}", err) - })); + })?; reject_transaction(&mut signer, U256::from(id)) } @@ -167,9 +167,9 @@ pub fn signer_sign( } let addr = &format!("ws://127.0.0.1:{}", signerport); - let mut signer = try!(SignerRpc::new(addr, &authfile).map_err(|err| { + let mut signer = SignerRpc::new(addr, &authfile).map_err(|err| { format!("{:?}", err) - })); + })?; match id { Some(id) => { diff --git a/rpc_client/src/client.rs b/rpc_client/src/client.rs index c32b5be7a..4f0df5555 100644 --- a/rpc_client/src/client.rs +++ b/rpc_client/src/client.rs @@ -68,9 +68,9 @@ impl Handler for RpcHandler { fn build_request(&mut self, url: &Url) -> WsResult { match Request::from_url(url) { Ok(mut r) => { - let timestamp = try!(time::UNIX_EPOCH.elapsed().map_err(|err| { + let timestamp = time::UNIX_EPOCH.elapsed().map_err(|err| { WsError::new(WsErrorKind::Internal, format!("{}", err)) - })); + })?; let secs = timestamp.as_secs(); let hashed = format!("{}:{}", self.auth_code, secs).sha3(); let proto = format!("{:?}_{}", hashed, secs); @@ -195,7 +195,7 @@ pub struct Rpc { impl Rpc { /// Blocking, returns a new initialized connection or RpcError pub fn new(url: &str, authpath: &PathBuf) -> Result { - let rpc = try!(Self::connect(url, authpath).map(|rpc| rpc).wait()); + let rpc = Self::connect(url, authpath).map(|rpc| rpc).wait()?; rpc } /// Non-blocking, returns a future @@ -260,7 +260,7 @@ impl Rpc { p.map(|result| { match result { Ok(json) => { - let t: T = try!(json::from_value(json)); + let t: T = json::from_value(json)?; Ok(t) }, Err(err) => Err(err) diff --git a/rpc_client/src/signer_client.rs b/rpc_client/src/signer_client.rs index 6284111ca..53a9becc3 100644 --- a/rpc_client/src/signer_client.rs +++ b/rpc_client/src/signer_client.rs @@ -10,7 +10,7 @@ pub struct SignerRpc { impl SignerRpc { pub fn new(url: &str, authfile: &PathBuf) -> Result { - Ok(SignerRpc { rpc: try!(Rpc::new(&url, authfile)) }) + Ok(SignerRpc { rpc: Rpc::new(&url, authfile)? }) } pub fn requests_to_confirm(&mut self) -> BoxFuture, RpcError>, Canceled> diff --git a/scripts/contractABI.js b/scripts/contractABI.js index 29659ee09..e6c8e923a 100644 --- a/scripts/contractABI.js +++ b/scripts/contractABI.js @@ -195,25 +195,25 @@ function tokenCoerce(name, type, _prefs) { } function tokenExtract(expr, type, _prefs) { - return `{ let r = ${expr}; let r = try!(${tokenType('r', type, _prefs)}.ok_or("Invalid type returned")); ${tokenCoerce('r', type, _prefs)} }`; + return `{ let r = ${expr}; let r = ${tokenType('r', type, _prefs)}.ok_or("Invalid type returned")?; ${tokenCoerce('r', type, _prefs)} }`; } function convertFunction(json, _prefs) { let prefs = (_prefs || {})[json.name] || (_prefs || {})['_'] || {}; let snakeName = json.name.toSnake(); let params = json.inputs.map((x, i) => (x.name ? x.name.toSnake() : ("_" + (i + 1))) + ": " + mapType(x.name, x.type, prefs[x.name])); - let returns = json.outputs.length != 1 ? "(" + json.outputs.map(x => mapReturnType(x.name, x.type, prefs[x.name])).join(", ") + ")" : mapReturnType(json.outputs[0].name, json.outputs[0].type, prefs[json.outputs[0].name]); + let returns = json.outputs.length != 1 ? "(" + json.outputs.map(x => mapReturnType(x.name, x.type, prefs[x.name])).join(", ") + ")" : mapReturnType(json.outputs[0].name, json.outputs[0].type, prefs[json.outputs[0].name]); return ` /// Auto-generated from: \`${JSON.stringify(json)}\` #[allow(dead_code)] - pub fn ${snakeName}(&self${params.length > 0 ? ', ' + params.join(", ") : ''}) -> Result<${returns}, String> { + pub fn ${snakeName}(&self${params.length > 0 ? ', ' + params.join(", ") : ''}) -> Result<${returns}, String> { let call = self.contract.function("${json.name}".into()).map_err(Self::as_string)?; let data = call.encode_call( vec![${json.inputs.map((x, i) => convertToken(x.name ? x.name.toSnake() : ("_" + (i + 1)), x.type, prefs[x.name])).join(', ')}] ).map_err(Self::as_string)?; ${json.outputs.length > 0 ? 'let output = ' : ''}call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; ${json.outputs.length > 0 ? 'let mut result = output.into_iter().rev().collect::>();' : ''} - Ok((${json.outputs.map((o, i) => tokenExtract('result.pop().ok_or("Invalid return arity")?', o.type, prefs[o.name])).join(', ')})) + Ok((${json.outputs.map((o, i) => tokenExtract('result.pop().ok_or("Invalid return arity")?', o.type, prefs[o.name])).join(', ')})) }`; } diff --git a/signer/src/authcode_store.rs b/signer/src/authcode_store.rs index 3752923fa..d5f962d93 100644 --- a/signer/src/authcode_store.rs +++ b/signer/src/authcode_store.rs @@ -85,7 +85,7 @@ impl AuthCodes { let content = { if let Ok(mut file) = fs::File::open(file) { let mut s = String::new(); - let _ = try!(file.read_to_string(&mut s)); + let _ = file.read_to_string(&mut s)?; s } else { "".into() @@ -126,7 +126,7 @@ impl AuthCodes { /// Writes all `AuthCodes` to a disk. pub fn to_file(&self, file: &Path) -> io::Result<()> { - let mut file = try!(fs::File::create(file)); + let mut file = fs::File::create(file)?; let content = self.codes.iter().map(|code| { let mut data = vec![code.code.clone(), encode_time(code.created_at.clone())]; if let Some(used_at) = code.last_used_at { @@ -185,7 +185,7 @@ impl AuthCodes { /// Generates and returns a new code that can be used by `SignerUIs` pub fn generate_new(&mut self) -> io::Result { - let mut rng = try!(OsRng::new()); + let mut rng = OsRng::new()?; let code = rng.gen_ascii_chars().take(TOKEN_LENGTH).collect::(); let readable_code = code.as_bytes() .chunks(4) diff --git a/signer/src/ws_server/mod.rs b/signer/src/ws_server/mod.rs index 261715036..83b0e23e6 100644 --- a/signer/src/ws_server/mod.rs +++ b/signer/src/ws_server/mod.rs @@ -116,9 +116,9 @@ impl Server { // Create WebSocket let origin = format!("{}", addr); - let ws = try!(ws::Builder::new().with_settings(config).build( + let ws = ws::Builder::new().with_settings(config).build( session::Factory::new(handler, origin, authcodes_path, skip_origin_validation) - )); + )?; let panic_handler = PanicHandler::new_in_arc(); let ph = panic_handler.clone(); diff --git a/signer/src/ws_server/session.rs b/signer/src/ws_server/session.rs index 77699fa93..852b83f15 100644 --- a/signer/src/ws_server/session.rs +++ b/signer/src/ws_server/session.rs @@ -207,7 +207,7 @@ impl ws::Handler for Session { } fn on_message(&mut self, msg: ws::Message) -> ws::Result<()> { - let req = try!(msg.as_text()); + let req = msg.as_text()?; let out = self.out.clone(); self.handler.handle_request(req, move |response| { if let Some(result) = response { diff --git a/stratum/src/lib.rs b/stratum/src/lib.rs index 7a5761aae..bb0ca7b22 100644 --- a/stratum/src/lib.rs +++ b/stratum/src/lib.rs @@ -74,7 +74,7 @@ impl Stratum { secret: Option, ) -> Result, jsonrpc_tcp_server::Error> { let handler = Arc::new(IoHandler::new()); - let server = try!(JsonRpcServer::new(addr, &handler)); + let server = JsonRpcServer::new(addr, &handler)?; let stratum = Arc::new(Stratum { rpc_server: server, handler: handler, @@ -90,7 +90,7 @@ impl Stratum { delegate.add_method("miner.authorize", Stratum::authorize); stratum.handler.add_delegate(delegate); - try!(stratum.rpc_server.run_async()); + stratum.rpc_server.run_async()?; Ok(stratum) } @@ -163,7 +163,7 @@ impl PushWorkHandler for Stratum { let workers = self.workers.read(); println!("pushing work for {} workers", workers.len()); for (ref addr, _) in workers.iter() { - try!(self.rpc_server.push_message(addr, payload.as_bytes())); + self.rpc_server.push_message(addr, payload.as_bytes())?; } Ok(()) } @@ -182,12 +182,10 @@ impl PushWorkHandler for Stratum { while que.len() > 0 { let next_worker = addrs[addr_index]; let mut next_payload = que.drain(0..1); - try!( - self.rpc_server.push_message( + self.rpc_server.push_message( next_worker, next_payload.nth(0).expect("drained successfully of 0..1, so 0-th element should exist").as_bytes() - ) - ); + )?; addr_index = addr_index + 1; } Ok(()) diff --git a/sync/src/api.rs b/sync/src/api.rs index d623ba9c3..6237b3dc1 100644 --- a/sync/src/api.rs +++ b/sync/src/api.rs @@ -183,7 +183,7 @@ impl EthSync { }; let chain_sync = ChainSync::new(params.config, &*params.chain); - let service = try!(NetworkService::new(try!(params.network_config.clone().into_basic()))); + let service = NetworkService::new(params.network_config.clone().into_basic()?)?; let sync = Arc::new(EthSync { network: service, @@ -507,8 +507,8 @@ impl NetworkConfiguration { Ok(BasicNetworkConfiguration { config_path: self.config_path, net_config_path: self.net_config_path, - listen_address: match self.listen_address { None => None, Some(addr) => Some(try!(SocketAddr::from_str(&addr))) }, - public_address: match self.public_address { None => None, Some(addr) => Some(try!(SocketAddr::from_str(&addr))) }, + listen_address: match self.listen_address { None => None, Some(addr) => Some(SocketAddr::from_str(&addr)?) }, + public_address: match self.public_address { None => None, Some(addr) => Some(SocketAddr::from_str(&addr)?) }, udp_port: self.udp_port, nat_enabled: self.nat_enabled, discovery_enabled: self.discovery_enabled, diff --git a/sync/src/block_sync.rs b/sync/src/block_sync.rs index e5b13835b..7c423f7c2 100644 --- a/sync/src/block_sync.rs +++ b/sync/src/block_sync.rs @@ -208,10 +208,10 @@ impl BlockDownloader { let mut valid_response = item_count == 0; //empty response is valid let mut any_known = false; for i in 0..item_count { - let info: BlockHeader = try!(r.val_at(i).map_err(|e| { + let info: BlockHeader = r.val_at(i).map_err(|e| { trace!(target: "sync", "Error decoding block header RLP: {:?}", e); BlockDownloaderImportError::Invalid - })); + })?; let number = BlockNumber::from(info.number()); // Check if any of the headers matches the hash we requested if !valid_response { @@ -229,10 +229,10 @@ impl BlockDownloader { self.highest_block = Some(number); } let hash = info.hash(); - let hdr = try!(r.at(i).map_err(|e| { + let hdr = r.at(i).map_err(|e| { trace!(target: "sync", "Error decoding block header RLP: {:?}", e); BlockDownloaderImportError::Invalid - })); + })?; match io.chain().block_status(BlockId::Hash(hash.clone())) { BlockStatus::InChain | BlockStatus::Queued => { match self.state { @@ -302,10 +302,10 @@ impl BlockDownloader { else { let mut bodies = Vec::with_capacity(item_count); for i in 0..item_count { - let body = try!(r.at(i).map_err(|e| { + let body = r.at(i).map_err(|e| { trace!(target: "sync", "Error decoding block boides RLP: {:?}", e); BlockDownloaderImportError::Invalid - })); + })?; bodies.push(body.as_raw().to_vec()); } if self.blocks.insert_bodies(bodies) != item_count { @@ -328,10 +328,10 @@ impl BlockDownloader { else { let mut receipts = Vec::with_capacity(item_count); for i in 0..item_count { - let receipt = try!(r.at(i).map_err(|e| { + let receipt = r.at(i).map_err(|e| { trace!(target: "sync", "Error decoding block receipts RLP: {:?}", e); BlockDownloaderImportError::Invalid - })); + })?; receipts.push(receipt.as_raw().to_vec()); } if self.blocks.insert_receipts(receipts) != item_count { diff --git a/sync/src/blocks.rs b/sync/src/blocks.rs index 686b49218..57d9c7f23 100644 --- a/sync/src/blocks.rs +++ b/sync/src/blocks.rs @@ -329,9 +329,9 @@ impl BlockCollection { fn insert_body(&mut self, b: Bytes) -> Result<(), NetworkError> { let header_id = { let body = UntrustedRlp::new(&b); - let tx = try!(body.at(0)); + let tx = body.at(0)?; let tx_root = ordered_trie_root(tx.iter().map(|r| r.as_raw().to_vec())); //TODO: get rid of vectors here - let uncles = try!(body.at(1)).as_raw().sha3(); + let uncles = body.at(1)?.as_raw().sha3(); HeaderId { transactions_root: tx_root, uncles: uncles @@ -390,7 +390,7 @@ impl BlockCollection { } fn insert_header(&mut self, header: Bytes) -> Result { - let info: BlockHeader = try!(UntrustedRlp::new(&header).as_val()); + let info: BlockHeader = UntrustedRlp::new(&header).as_val()?; let hash = info.hash(); if self.blocks.contains_key(&hash) { return Ok(hash); diff --git a/sync/src/chain.rs b/sync/src/chain.rs index 72b1cf568..b38244dc1 100644 --- a/sync/src/chain.rs +++ b/sync/src/chain.rs @@ -584,14 +584,14 @@ impl ChainSync { /// Called by peer to report status fn on_peer_status(&mut self, io: &mut SyncIo, peer_id: PeerId, r: &UntrustedRlp) -> Result<(), PacketDecodeError> { self.handshaking_peers.remove(&peer_id); - let protocol_version: u8 = try!(r.val_at(0)); + let protocol_version: u8 = r.val_at(0)?; let warp_protocol = io.protocol_version(&WARP_SYNC_PROTOCOL_ID, peer_id) != 0; let peer = PeerInfo { protocol_version: protocol_version, - network_id: try!(r.val_at(1)), - difficulty: Some(try!(r.val_at(2))), - latest_hash: try!(r.val_at(3)), - genesis: try!(r.val_at(4)), + network_id: r.val_at(1)?, + difficulty: Some(r.val_at(2)?), + latest_hash: r.val_at(3)?, + genesis: r.val_at(4)?, asking: PeerAsking::Nothing, asking_blocks: Vec::new(), asking_hash: None, @@ -600,8 +600,8 @@ impl ChainSync { expired: false, confirmation: if self.fork_block.is_none() { ForkConfirmation::Confirmed } else { ForkConfirmation::Unconfirmed }, asking_snapshot_data: None, - snapshot_hash: if warp_protocol { Some(try!(r.val_at(5))) } else { None }, - snapshot_number: if warp_protocol { Some(try!(r.val_at(6))) } else { None }, + snapshot_hash: if warp_protocol { Some(r.val_at(5)?) } else { None }, + snapshot_number: if warp_protocol { Some(r.val_at(6)?) } else { None }, block_set: None, }; @@ -662,7 +662,7 @@ impl ChainSync { trace!(target: "sync", "{}: Chain is too short to confirm the block", peer_id); peer.confirmation = ForkConfirmation::TooShort; } else { - let header = try!(r.at(0)).as_raw(); + let header = r.at(0)?.as_raw(); if header.sha3() == fork_hash { trace!(target: "sync", "{}: Confirmed peer", peer_id); peer.confirmation = ForkConfirmation::Confirmed; @@ -867,17 +867,17 @@ impl ChainSync { trace!(target: "sync", "Ignoring new block from unconfirmed peer {}", peer_id); return Ok(()); } - let difficulty: U256 = try!(r.val_at(1)); + let difficulty: U256 = r.val_at(1)?; if let Some(ref mut peer) = self.peers.get_mut(&peer_id) { if peer.difficulty.map_or(true, |pd| difficulty > pd) { peer.difficulty = Some(difficulty); } } - let block_rlp = try!(r.at(0)); - let header_rlp = try!(block_rlp.at(0)); + let block_rlp = r.at(0)?; + let header_rlp = block_rlp.at(0)?; let h = header_rlp.as_raw().sha3(); trace!(target: "sync", "{} -> NewBlock ({})", peer_id, h); - let header: BlockHeader = try!(header_rlp.as_val()); + let header: BlockHeader = header_rlp.as_val()?; if header.number() > self.highest_block.unwrap_or(0) { self.highest_block = Some(header.number()); } @@ -956,8 +956,8 @@ impl ChainSync { let mut new_hashes = Vec::new(); let last_imported_number = self.new_blocks.last_imported_block_number(); for (rh, rn) in hashes { - let hash = try!(rh); - let number = try!(rn); + let hash = rh?; + let number = rn?; if number > self.highest_block.unwrap_or(0) { self.highest_block = Some(number); } @@ -1016,7 +1016,7 @@ impl ChainSync { return Ok(()); } - let manifest_rlp = try!(r.at(0)); + let manifest_rlp = r.at(0)?; let manifest = match ManifestData::from_rlp(manifest_rlp.as_raw()) { Err(e) => { trace!(target: "sync", "{}: Ignored bad manifest: {:?}", peer_id, e); @@ -1064,7 +1064,7 @@ impl ChainSync { }, } - let snapshot_data: Bytes = try!(r.val_at(0)); + let snapshot_data: Bytes = r.val_at(0)?; match self.snapshot.validate_chunk(&snapshot_data) { Ok(ChunkType::Block(hash)) => { trace!(target: "sync", "{}: Processing block chunk", peer_id); @@ -1441,7 +1441,7 @@ impl ChainSync { item_count = min(item_count, MAX_TX_TO_IMPORT); let mut transactions = Vec::with_capacity(item_count); for i in 0 .. item_count { - let rlp = try!(r.at(i)); + let rlp = r.at(i)?; if rlp.as_raw().len() > MAX_TRANSACTION_SIZE { debug!("Skipped oversized transaction of {} bytes", rlp.as_raw().len()); continue; @@ -1483,13 +1483,13 @@ impl ChainSync { fn return_block_headers(io: &SyncIo, r: &UntrustedRlp, peer_id: PeerId) -> RlpResponseResult { // Packet layout: // [ block: { P , B_32 }, maxHeaders: P, skip: P, reverse: P in { 0 , 1 } ] - let max_headers: usize = try!(r.val_at(1)); - let skip: usize = try!(r.val_at(2)); - let reverse: bool = try!(r.val_at(3)); + let max_headers: usize = r.val_at(1)?; + let skip: usize = r.val_at(2)?; + let reverse: bool = r.val_at(3)?; let last = io.chain().chain_info().best_block_number; - let number = if try!(r.at(0)).size() == 32 { + let number = if r.at(0)?.size() == 32 { // id is a hash - let hash: H256 = try!(r.val_at(0)); + let hash: H256 = r.val_at(0)?; trace!(target: "sync", "{} -> GetBlockHeaders (hash: {}, max: {}, skip: {}, reverse:{})", peer_id, hash, max_headers, skip, reverse); match io.chain().block_header(BlockId::Hash(hash)) { Some(hdr) => { @@ -1508,8 +1508,8 @@ impl ChainSync { None => return Ok(Some((BLOCK_HEADERS_PACKET, RlpStream::new_list(0)))) //no such header, return nothing } } else { - trace!(target: "sync", "{} -> GetBlockHeaders (number: {}, max: {}, skip: {}, reverse:{})", peer_id, try!(r.val_at::(0)), max_headers, skip, reverse); - try!(r.val_at(0)) + trace!(target: "sync", "{} -> GetBlockHeaders (number: {}, max: {}, skip: {}, reverse:{})", peer_id, r.val_at::(0)?, max_headers, skip, reverse); + r.val_at(0)? }; let mut number = if reverse { @@ -1562,7 +1562,7 @@ impl ChainSync { let mut added = 0usize; let mut data = Bytes::new(); for i in 0..count { - if let Some(mut hdr) = io.chain().block_body(BlockId::Hash(try!(r.val_at::(i)))) { + if let Some(mut hdr) = io.chain().block_body(BlockId::Hash(r.val_at::(i)?)) { data.append(&mut hdr); added += 1; } @@ -1585,7 +1585,7 @@ impl ChainSync { let mut added = 0usize; let mut data = Vec::new(); for i in 0..count { - if let Some(hdr) = io.chain().state_data(&try!(r.val_at::(i))) { + if let Some(hdr) = io.chain().state_data(&r.val_at::(i)?) { data.push(hdr); added += 1; } @@ -1610,7 +1610,7 @@ impl ChainSync { let mut added_receipts = 0usize; let mut data = Bytes::new(); for i in 0..count { - if let Some(mut receipts_bytes) = io.chain().block_receipts(&try!(rlp.val_at::(i))) { + if let Some(mut receipts_bytes) = io.chain().block_receipts(&rlp.val_at::(i)?) { data.append(&mut receipts_bytes); added_receipts += receipts_bytes.len(); added_headers += 1; @@ -1647,7 +1647,7 @@ impl ChainSync { /// Respond to GetSnapshotData request fn return_snapshot_data(io: &SyncIo, r: &UntrustedRlp, peer_id: PeerId) -> RlpResponseResult { - let hash: H256 = try!(r.val_at(0)); + let hash: H256 = r.val_at(0)?; trace!(target: "sync", "{} -> GetSnapshotData {:?}", peer_id, hash); let rlp = match io.snapshot_service().chunk(hash) { Some(data) => { diff --git a/updater/src/operations.rs b/updater/src/operations.rs index 26652f384..c67abcc75 100644 --- a/updater/src/operations.rs +++ b/updater/src/operations.rs @@ -42,7 +42,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bool().ok_or("Invalid type returned")); r })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bool().ok_or("Invalid type returned")?; r })) } /// Auto-generated from: `{"constant":false,"inputs":[{"name":"_txid","type":"bytes32"}],"name":"rejectTransaction","outputs":[],"payable":false,"type":"function"}` @@ -102,7 +102,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()).as_u64() as u32 }, { let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()).as_u64() as u8 }, { let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()).as_u64() as u32 }, { let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bool().ok_or("Invalid type returned")); r })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()).as_u64() as u32 }, { let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()).as_u64() as u8 }, { let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()).as_u64() as u32 }, { let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bool().ok_or("Invalid type returned")?; r })) } /// Auto-generated from: `{"constant":true,"inputs":[{"name":"_client","type":"bytes32"},{"name":"_checksum","type":"bytes32"}],"name":"build","outputs":[{"name":"o_release","type":"bytes32"},{"name":"o_platform","type":"bytes32"}],"payable":false,"type":"function"}` @@ -114,7 +114,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_fixed_bytes().ok_or("Invalid type returned")); util::H256::from_slice(r.as_ref()) }, { let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_fixed_bytes().ok_or("Invalid type returned")); util::H256::from_slice(r.as_ref()) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_fixed_bytes().ok_or("Invalid type returned")?; util::H256::from_slice(r.as_ref()) }, { let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_fixed_bytes().ok_or("Invalid type returned")?; util::H256::from_slice(r.as_ref()) })) } /// Auto-generated from: `{"constant":false,"inputs":[],"name":"rejectFork","outputs":[],"payable":false,"type":"function"}` @@ -138,7 +138,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_address().ok_or("Invalid type returned")); util::Address::from(r) }, { let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bool().ok_or("Invalid type returned")); r })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_address().ok_or("Invalid type returned")?; util::Address::from(r) }, { let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bool().ok_or("Invalid type returned")?; r })) } /// Auto-generated from: `{"constant":false,"inputs":[{"name":"_newOwner","type":"address"}],"name":"setClientOwner","outputs":[],"payable":false,"type":"function"}` @@ -162,7 +162,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_fixed_bytes().ok_or("Invalid type returned")); util::H256::from_slice(r.as_ref()) }, { let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_fixed_bytes().ok_or("Invalid type returned")); util::H256::from_slice(r.as_ref()) }, { let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bool().ok_or("Invalid type returned")); r }, { let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bool().ok_or("Invalid type returned")); r }, { let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_fixed_bytes().ok_or("Invalid type returned")?; util::H256::from_slice(r.as_ref()) }, { let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_fixed_bytes().ok_or("Invalid type returned")?; util::H256::from_slice(r.as_ref()) }, { let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bool().ok_or("Invalid type returned")?; r }, { let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bool().ok_or("Invalid type returned")?; r }, { let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()) })) } /// Auto-generated from: `{"constant":false,"inputs":[{"name":"_release","type":"bytes32"},{"name":"_platform","type":"bytes32"},{"name":"_checksum","type":"bytes32"}],"name":"addChecksum","outputs":[],"payable":false,"type":"function"}` @@ -186,7 +186,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()) })) } /// Auto-generated from: `{"constant":true,"inputs":[{"name":"","type":"bytes32"}],"name":"proxy","outputs":[{"name":"requiredCount","type":"uint256"},{"name":"to","type":"address"},{"name":"data","type":"bytes"},{"name":"value","type":"uint256"},{"name":"gas","type":"uint256"}],"payable":false,"type":"function"}` @@ -198,7 +198,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()) }, { let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_address().ok_or("Invalid type returned")); util::Address::from(r) }, { let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_bytes().ok_or("Invalid type returned")); r }, { let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()) }, { let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()) }, { let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_address().ok_or("Invalid type returned")?; util::Address::from(r) }, { let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_bytes().ok_or("Invalid type returned")?; r }, { let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()) }, { let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()) })) } /// Auto-generated from: `{"constant":false,"inputs":[{"name":"_client","type":"bytes32"},{"name":"_owner","type":"address"}],"name":"addClient","outputs":[],"payable":false,"type":"function"}` @@ -222,7 +222,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_fixed_bytes().ok_or("Invalid type returned")); util::H256::from_slice(r.as_ref()) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_fixed_bytes().ok_or("Invalid type returned")?; util::H256::from_slice(r.as_ref()) })) } /// Auto-generated from: `{"constant":false,"inputs":[{"name":"_txid","type":"bytes32"},{"name":"_to","type":"address"},{"name":"_data","type":"bytes"},{"name":"_value","type":"uint256"},{"name":"_gas","type":"uint256"}],"name":"proposeTransaction","outputs":[{"name":"txSuccess","type":"uint256"}],"payable":false,"type":"function"}` @@ -234,7 +234,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()) })) } /// Auto-generated from: `{"constant":true,"inputs":[],"name":"grandOwner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"}` @@ -246,7 +246,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_address().ok_or("Invalid type returned")); util::Address::from(r) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_address().ok_or("Invalid type returned")?; util::Address::from(r) })) } /// Auto-generated from: `{"constant":false,"inputs":[{"name":"_release","type":"bytes32"},{"name":"_forkBlock","type":"uint32"},{"name":"_track","type":"uint8"},{"name":"_semver","type":"uint24"},{"name":"_critical","type":"bool"}],"name":"addRelease","outputs":[],"payable":false,"type":"function"}` @@ -282,7 +282,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()).as_u64() as u32 })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()).as_u64() as u32 })) } /// Auto-generated from: `{"constant":true,"inputs":[{"name":"_client","type":"bytes32"},{"name":"_release","type":"bytes32"}],"name":"track","outputs":[{"name":"","type":"uint8"}],"payable":false,"type":"function"}` @@ -294,7 +294,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()).as_u64() as u8 })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()).as_u64() as u8 })) } /// Auto-generated from: `{"constant":false,"inputs":[{"name":"_client","type":"bytes32"},{"name":"_r","type":"bool"}],"name":"setClientRequired","outputs":[],"payable":false,"type":"function"}` @@ -318,7 +318,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()).as_u64() as u32 })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()).as_u64() as u32 })) } /// Auto-generated from: `{"constant":true,"inputs":[{"name":"_client","type":"bytes32"},{"name":"_track","type":"uint8"}],"name":"latestInTrack","outputs":[{"name":"","type":"bytes32"}],"payable":false,"type":"function"}` @@ -330,7 +330,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_fixed_bytes().ok_or("Invalid type returned")); util::H256::from_slice(r.as_ref()) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_fixed_bytes().ok_or("Invalid type returned")?; util::H256::from_slice(r.as_ref()) })) } /// Auto-generated from: `{"constant":true,"inputs":[{"name":"_client","type":"bytes32"},{"name":"_release","type":"bytes32"},{"name":"_platform","type":"bytes32"}],"name":"checksum","outputs":[{"name":"","type":"bytes32"}],"payable":false,"type":"function"}` @@ -342,7 +342,7 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_fixed_bytes().ok_or("Invalid type returned")); util::H256::from_slice(r.as_ref()) })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_fixed_bytes().ok_or("Invalid type returned")?; util::H256::from_slice(r.as_ref()) })) } /// Auto-generated from: `{"constant":true,"inputs":[],"name":"proposedFork","outputs":[{"name":"","type":"uint32"}],"payable":false,"type":"function"}` @@ -354,6 +354,6 @@ impl Operations { ).map_err(Self::as_string)?; let output = call.decode_output((self.do_call)(self.address.clone(), data)?).map_err(Self::as_string)?; let mut result = output.into_iter().rev().collect::>(); - Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = try!(r.to_uint().ok_or("Invalid type returned")); util::U256::from(r.as_ref()).as_u64() as u32 })) + Ok(({ let r = result.pop().ok_or("Invalid return arity")?; let r = r.to_uint().ok_or("Invalid type returned")?; util::U256::from(r.as_ref()).as_u64() as u32 })) } } \ No newline at end of file diff --git a/util/bigint/src/hash.rs b/util/bigint/src/hash.rs index cbfadc621..fb9fbbd72 100644 --- a/util/bigint/src/hash.rs +++ b/util/bigint/src/hash.rs @@ -167,7 +167,7 @@ macro_rules! impl_hash { type Err = FromHexError; fn from_str(s: &str) -> Result<$from, FromHexError> { - let a = try!(s.from_hex()); + let a = s.from_hex()?; if a.len() != $size { return Err(FromHexError::InvalidHexLength); } @@ -181,7 +181,7 @@ macro_rules! impl_hash { impl fmt::Debug for $from { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { for i in &self.0[..] { - try!(write!(f, "{:02x}", i)); + write!(f, "{:02x}", i)?; } Ok(()) } @@ -190,11 +190,11 @@ macro_rules! impl_hash { impl fmt::Display for $from { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { for i in &self.0[0..2] { - try!(write!(f, "{:02x}", i)); + write!(f, "{:02x}", i)?; } - try!(write!(f, "…")); + write!(f, "…")?; for i in &self.0[$size - 2..$size] { - try!(write!(f, "{:02x}", i)); + write!(f, "{:02x}", i)?; } Ok(()) } diff --git a/util/fetch/src/client.rs b/util/fetch/src/client.rs index 4fcc3d148..1005e34de 100644 --- a/util/fetch/src/client.rs +++ b/util/fetch/src/client.rs @@ -83,7 +83,7 @@ impl Client { } fn with_limit(limit: Option) -> Result { - let mut client = try!(reqwest::Client::new()); + let mut client = reqwest::Client::new()?; client.redirect(reqwest::RedirectPolicy::limited(5)); Ok(Client { @@ -134,9 +134,9 @@ impl Future for FetchTask { } trace!(target: "fetch", "Starting fetch task: {:?}", self.url); - let result = try!(self.client.get(&self.url) + let result = self.client.get(&self.url) .header(reqwest::header::UserAgent("Parity Fetch".into())) - .send()); + .send()?; Ok(futures::Async::Ready(Response { inner: ResponseInner::Response(result), diff --git a/util/io/src/service.rs b/util/io/src/service.rs index f41cd866b..6f5c87004 100644 --- a/util/io/src/service.rs +++ b/util/io/src/service.rs @@ -95,65 +95,65 @@ impl IoContext where Message: Send + Clone + Sync + 'static { /// Register a new recurring IO timer. 'IoHandler::timeout' will be called with the token. pub fn register_timer(&self, token: TimerToken, ms: u64) -> Result<(), IoError> { - try!(self.channel.send_io(IoMessage::AddTimer { + self.channel.send_io(IoMessage::AddTimer { token: token, delay: ms, handler_id: self.handler, once: false, - })); + })?; Ok(()) } /// Register a new IO timer once. 'IoHandler::timeout' will be called with the token. pub fn register_timer_once(&self, token: TimerToken, ms: u64) -> Result<(), IoError> { - try!(self.channel.send_io(IoMessage::AddTimer { + self.channel.send_io(IoMessage::AddTimer { token: token, delay: ms, handler_id: self.handler, once: true, - })); + })?; Ok(()) } /// Delete a timer. pub fn clear_timer(&self, token: TimerToken) -> Result<(), IoError> { - try!(self.channel.send_io(IoMessage::RemoveTimer { + self.channel.send_io(IoMessage::RemoveTimer { token: token, handler_id: self.handler, - })); + })?; Ok(()) } /// Register a new IO stream. pub fn register_stream(&self, token: StreamToken) -> Result<(), IoError> { - try!(self.channel.send_io(IoMessage::RegisterStream { + self.channel.send_io(IoMessage::RegisterStream { token: token, handler_id: self.handler, - })); + })?; Ok(()) } /// Deregister an IO stream. pub fn deregister_stream(&self, token: StreamToken) -> Result<(), IoError> { - try!(self.channel.send_io(IoMessage::DeregisterStream { + self.channel.send_io(IoMessage::DeregisterStream { token: token, handler_id: self.handler, - })); + })?; Ok(()) } /// Reregister an IO stream. pub fn update_registration(&self, token: StreamToken) -> Result<(), IoError> { - try!(self.channel.send_io(IoMessage::UpdateStreamRegistration { + self.channel.send_io(IoMessage::UpdateStreamRegistration { token: token, handler_id: self.handler, - })); + })?; Ok(()) } /// Broadcast a message to other IO clients pub fn message(&self, message: Message) -> Result<(), IoError> { - try!(self.channel.send(message)); + self.channel.send(message)?; Ok(()) } @@ -164,9 +164,9 @@ impl IoContext where Message: Send + Clone + Sync + 'static { /// Unregister current IO handler. pub fn unregister_handler(&self) -> Result<(), IoError> { - try!(self.channel.send_io(IoMessage::RemoveHandler { + self.channel.send_io(IoMessage::RemoveHandler { handler_id: self.handler, - })); + })?; Ok(()) } @@ -217,7 +217,7 @@ impl IoManager where Message: Send + Sync + Clone + 'static { workers: workers, work_ready: work_ready, }; - try!(event_loop.run(&mut io)); + event_loop.run(&mut io)?; Ok(()) } } @@ -356,8 +356,8 @@ impl IoChannel where Message: Send + Clone + Sync + 'static { /// Send a message through the channel pub fn send(&self, message: Message) -> Result<(), IoError> { match self.channel { - Some(ref channel) => try!(channel.send(IoMessage::UserMessage(message))), - None => try!(self.send_sync(message)) + Some(ref channel) => channel.send(IoMessage::UserMessage(message))?, + None => self.send_sync(message)? } Ok(()) } @@ -387,7 +387,7 @@ impl IoChannel where Message: Send + Clone + Sync + 'static { /// Send low level io message pub fn send_io(&self, message: IoMessage) -> Result<(), IoError> { if let Some(ref channel) = self.channel { - try!(channel.send(message)) + channel.send(message)? } Ok(()) } @@ -470,15 +470,15 @@ impl IoService where Message: Send + Sync + Clone + 'static { /// Regiter an IO handler with the event loop. pub fn register_handler(&self, handler: Arc+Send>) -> Result<(), IoError> { - try!(self.host_channel.lock().send(IoMessage::AddHandler { + self.host_channel.lock().send(IoMessage::AddHandler { handler: handler, - })); + })?; Ok(()) } /// Send a message over the network. Normaly `HostIo::send` should be used. This can be used from non-io threads. pub fn send_message(&self, message: Message) -> Result<(), IoError> { - try!(self.host_channel.lock().send(IoMessage::UserMessage(message))); + self.host_channel.lock().send(IoMessage::UserMessage(message))?; Ok(()) } diff --git a/util/network/src/connection.rs b/util/network/src/connection.rs index 0a43d18c1..22fb845f4 100644 --- a/util/network/src/connection.rs +++ b/util/network/src/connection.rs @@ -150,7 +150,7 @@ impl GenericConnection { }, Ok(Some(_)) => { panic!("Wrote past buffer");}, Ok(None) => Ok(WriteStatus::Ongoing), - Err(e) => try!(Err(e)) + Err(e) => Err(e)? } }.and_then(|r| { if r == WriteStatus::Complete { @@ -158,7 +158,7 @@ impl GenericConnection { } if self.send_queue.is_empty() { self.interest.remove(Ready::writable()); - try!(io.update_registration(self.token)); + io.update_registration(self.token)?; } Ok(r) }) @@ -207,7 +207,7 @@ impl Connection { pub fn try_clone(&self) -> io::Result { Ok(Connection { token: self.token, - socket: try!(self.socket.try_clone()), + socket: self.socket.try_clone()?, rec_buf: Vec::new(), rec_size: 0, send_queue: self.send_queue.clone(), @@ -300,7 +300,7 @@ pub struct EncryptedConnection { impl EncryptedConnection { /// Create an encrypted connection out of the handshake. pub fn new(handshake: &mut Handshake) -> Result { - let shared = try!(crypto::ecdh::agree(handshake.ecdhe.secret(), &handshake.remote_ephemeral)); + let shared = crypto::ecdh::agree(handshake.ecdhe.secret(), &handshake.remote_ephemeral)?; let mut nonce_material = H512::new(); if handshake.originated { handshake.remote_nonce.copy_to(&mut nonce_material[0..32]); @@ -334,7 +334,7 @@ impl EncryptedConnection { ingress_mac.update(&mac_material); ingress_mac.update(if handshake.originated { &handshake.ack_cipher } else { &handshake.auth_cipher }); - let old_connection = try!(handshake.connection.try_clone()); + let old_connection = handshake.connection.try_clone()?; let connection = ::std::mem::replace(&mut handshake.connection, old_connection); let mut enc = EncryptedConnection { connection: connection, @@ -396,7 +396,7 @@ impl EncryptedConnection { let length = ((((hdec[0] as u32) << 8) + (hdec[1] as u32)) << 8) + (hdec[2] as u32); let header_rlp = UntrustedRlp::new(&hdec[3..6]); - let protocol_id = try!(header_rlp.val_at::(0)); + let protocol_id = header_rlp.val_at::(0)?; self.payload_len = length as usize; self.protocol_id = protocol_id; @@ -448,19 +448,19 @@ impl EncryptedConnection { /// Readable IO handler. Tracker receive status and returns decoded packet if avaialable. pub fn readable(&mut self, io: &IoContext) -> Result, NetworkError> where Message: Send + Clone + Sync + 'static { - try!(io.clear_timer(self.connection.token)); + io.clear_timer(self.connection.token)?; if let EncryptedConnectionState::Header = self.read_state { - if let Some(data) = try!(self.connection.readable()) { - try!(self.read_header(&data)); - try!(io.register_timer(self.connection.token, RECIEVE_PAYLOAD_TIMEOUT)); + if let Some(data) = self.connection.readable()? { + self.read_header(&data)?; + io.register_timer(self.connection.token, RECIEVE_PAYLOAD_TIMEOUT)?; } }; if let EncryptedConnectionState::Payload = self.read_state { - match try!(self.connection.readable()) { + match self.connection.readable()? { Some(data) => { self.read_state = EncryptedConnectionState::Header; self.connection.expect(ENCRYPTED_HEADER_LEN); - Ok(Some(try!(self.read_payload(&data)))) + Ok(Some(self.read_payload(&data)?)) }, None => Ok(None) } @@ -471,7 +471,7 @@ impl EncryptedConnection { /// Writable IO handler. Processes send queeue. pub fn writable(&mut self, io: &IoContext) -> Result<(), NetworkError> where Message: Send + Clone + Sync + 'static { - try!(self.connection.writable(io)); + self.connection.writable(io)?; Ok(()) } } diff --git a/util/network/src/discovery.rs b/util/network/src/discovery.rs index a6adf8d1d..98f2392a2 100644 --- a/util/network/src/discovery.rs +++ b/util/network/src/discovery.rs @@ -375,7 +375,7 @@ impl Discovery { let signed = &packet[(32 + 65)..]; let signature = H520::from_slice(&packet[32..(32 + 65)]); - let node_id = try!(recover(&signature.into(), &signed.sha3())); + let node_id = recover(&signature.into(), &signed.sha3())?; let packet_id = signed[0]; let rlp = UntrustedRlp::new(&signed[1..]); @@ -405,10 +405,10 @@ impl Discovery { fn on_ping(&mut self, rlp: &UntrustedRlp, node: &NodeId, from: &SocketAddr) -> Result, NetworkError> { trace!(target: "discovery", "Got Ping from {:?}", &from); - let source = try!(NodeEndpoint::from_rlp(&try!(rlp.at(1)))); - let dest = try!(NodeEndpoint::from_rlp(&try!(rlp.at(2)))); - let timestamp: u64 = try!(rlp.val_at(3)); - try!(self.check_timestamp(timestamp)); + let source = NodeEndpoint::from_rlp(&rlp.at(1)?)?; + let dest = NodeEndpoint::from_rlp(&rlp.at(2)?)?; + let timestamp: u64 = rlp.val_at(3)?; + self.check_timestamp(timestamp)?; let mut added_map = HashMap::new(); let entry = NodeEntry { id: node.clone(), endpoint: source.clone() }; if !entry.endpoint.is_valid() { @@ -431,9 +431,9 @@ impl Discovery { fn on_pong(&mut self, rlp: &UntrustedRlp, node: &NodeId, from: &SocketAddr) -> Result, NetworkError> { trace!(target: "discovery", "Got Pong from {:?}", &from); // TODO: validate pong packet - let dest = try!(NodeEndpoint::from_rlp(&try!(rlp.at(0)))); - let timestamp: u64 = try!(rlp.val_at(2)); - try!(self.check_timestamp(timestamp)); + let dest = NodeEndpoint::from_rlp(&rlp.at(0)?)?; + let timestamp: u64 = rlp.val_at(2)?; + self.check_timestamp(timestamp)?; let mut entry = NodeEntry { id: node.clone(), endpoint: dest }; if !entry.endpoint.is_valid() { debug!(target: "discovery", "Bad address: {:?}", entry); @@ -447,9 +447,9 @@ impl Discovery { fn on_find_node(&mut self, rlp: &UntrustedRlp, _node: &NodeId, from: &SocketAddr) -> Result, NetworkError> { trace!(target: "discovery", "Got FindNode from {:?}", &from); - let target: NodeId = try!(rlp.val_at(0)); - let timestamp: u64 = try!(rlp.val_at(1)); - try!(self.check_timestamp(timestamp)); + let target: NodeId = rlp.val_at(0)?; + let timestamp: u64 = rlp.val_at(1)?; + self.check_timestamp(timestamp)?; let nearest = Discovery::nearest_node_entries(&target, &self.node_buckets); if nearest.is_empty() { return Ok(None); @@ -481,14 +481,14 @@ impl Discovery { fn on_neighbours(&mut self, rlp: &UntrustedRlp, _node: &NodeId, from: &SocketAddr) -> Result, NetworkError> { // TODO: validate packet let mut added = HashMap::new(); - trace!(target: "discovery", "Got {} Neighbours from {:?}", try!(rlp.at(0)).item_count(), &from); - for r in try!(rlp.at(0)).iter() { - let endpoint = try!(NodeEndpoint::from_rlp(&r)); + trace!(target: "discovery", "Got {} Neighbours from {:?}", rlp.at(0)?.item_count(), &from); + for r in rlp.at(0)?.iter() { + let endpoint = NodeEndpoint::from_rlp(&r)?; if !endpoint.is_valid() { debug!(target: "discovery", "Bad address: {:?}", endpoint); continue; } - let node_id: NodeId = try!(r.val_at(3)); + let node_id: NodeId = r.val_at(3)?; if node_id == self.id { continue; } diff --git a/util/network/src/handshake.rs b/util/network/src/handshake.rs index 7364b06e7..eb04ce869 100644 --- a/util/network/src/handshake.rs +++ b/util/network/src/handshake.rs @@ -89,7 +89,7 @@ impl Handshake { connection: Connection::new(token, socket, stats), originated: false, state: HandshakeState::New, - ecdhe: try!(Random.generate()), + ecdhe: Random.generate()?, nonce: nonce.clone(), remote_ephemeral: Public::new(), remote_nonce: H256::new(), @@ -110,7 +110,7 @@ impl Handshake { self.originated = originated; io.register_timer(self.connection.token, HANDSHAKE_TIMEOUT).ok(); if originated { - try!(self.write_auth(io, host.secret(), host.id())); + self.write_auth(io, host.secret(), host.id())?; } else { self.state = HandshakeState::ReadingAuth; @@ -127,21 +127,21 @@ impl Handshake { /// Readable IO handler. Drives the state change. pub fn readable(&mut self, io: &IoContext, host: &HostInfo) -> Result<(), NetworkError> where Message: Send + Clone + Sync + 'static { if !self.expired() { - while let Some(data) = try!(self.connection.readable()) { + while let Some(data) = self.connection.readable()? { match self.state { HandshakeState::New => {}, HandshakeState::StartSession => {}, HandshakeState::ReadingAuth => { - try!(self.read_auth(io, host.secret(), &data)); + self.read_auth(io, host.secret(), &data)?; }, HandshakeState::ReadingAuthEip8 => { - try!(self.read_auth_eip8(io, host.secret(), &data)); + self.read_auth_eip8(io, host.secret(), &data)?; }, HandshakeState::ReadingAck => { - try!(self.read_ack(host.secret(), &data)); + self.read_ack(host.secret(), &data)?; }, HandshakeState::ReadingAckEip8 => { - try!(self.read_ack_eip8(host.secret(), &data)); + self.read_ack_eip8(host.secret(), &data)?; }, } if self.state == HandshakeState::StartSession { @@ -156,7 +156,7 @@ impl Handshake { /// Writabe IO handler. pub fn writable(&mut self, io: &IoContext) -> Result<(), NetworkError> where Message: Send + Clone + Sync + 'static { if !self.expired() { - try!(self.connection.writable(io)); + self.connection.writable(io)?; } Ok(()) } @@ -165,9 +165,9 @@ impl Handshake { self.id.clone_from_slice(remote_public); self.remote_nonce.clone_from_slice(remote_nonce); self.remote_version = remote_version; - let shared = try!(ecdh::agree(host_secret, &self.id)); + let shared = ecdh::agree(host_secret, &self.id)?; let signature = H520::from_slice(sig); - self.remote_ephemeral = try!(recover(&signature.into(), &(&shared ^ &self.remote_nonce))); + self.remote_ephemeral = recover(&signature.into(), &(&shared ^ &self.remote_nonce))?; Ok(()) } @@ -185,8 +185,8 @@ impl Handshake { let (_, rest) = rest.split_at(32); let (pubk, rest) = rest.split_at(64); let (nonce, _) = rest.split_at(32); - try!(self.set_auth(secret, sig, pubk, nonce, PROTOCOL_VERSION)); - try!(self.write_ack(io)); + self.set_auth(secret, sig, pubk, nonce, PROTOCOL_VERSION)?; + self.write_ack(io)?; } Err(_) => { // Try to interpret as EIP-8 packet @@ -206,14 +206,14 @@ impl Handshake { fn read_auth_eip8(&mut self, io: &IoContext, secret: &Secret, data: &[u8]) -> Result<(), NetworkError> where Message: Send + Clone + Sync + 'static { trace!(target: "network", "Received EIP8 handshake auth from {:?}", self.connection.remote_addr_str()); self.auth_cipher.extend_from_slice(data); - let auth = try!(ecies::decrypt(secret, &self.auth_cipher[0..2], &self.auth_cipher[2..])); + let auth = ecies::decrypt(secret, &self.auth_cipher[0..2], &self.auth_cipher[2..])?; let rlp = UntrustedRlp::new(&auth); - let signature: H520 = try!(rlp.val_at(0)); - let remote_public: Public = try!(rlp.val_at(1)); - let remote_nonce: H256 = try!(rlp.val_at(2)); - let remote_version: u64 = try!(rlp.val_at(3)); - try!(self.set_auth(secret, &signature, &remote_public, &remote_nonce, remote_version)); - try!(self.write_ack_eip8(io)); + let signature: H520 = rlp.val_at(0)?; + let remote_public: Public = rlp.val_at(1)?; + let remote_nonce: H256 = rlp.val_at(2)?; + let remote_version: u64 = rlp.val_at(3)?; + self.set_auth(secret, &signature, &remote_public, &remote_nonce, remote_version)?; + self.write_ack_eip8(io)?; Ok(()) } @@ -249,11 +249,11 @@ impl Handshake { fn read_ack_eip8(&mut self, secret: &Secret, data: &[u8]) -> Result<(), NetworkError> { trace!(target: "network", "Received EIP8 handshake auth from {:?}", self.connection.remote_addr_str()); self.ack_cipher.extend_from_slice(data); - let ack = try!(ecies::decrypt(secret, &self.ack_cipher[0..2], &self.ack_cipher[2..])); + let ack = ecies::decrypt(secret, &self.ack_cipher[0..2], &self.ack_cipher[2..])?; let rlp = UntrustedRlp::new(&ack); - self.remote_ephemeral = try!(rlp.val_at(0)); - self.remote_nonce = try!(rlp.val_at(1)); - self.remote_version = try!(rlp.val_at(2)); + self.remote_ephemeral = rlp.val_at(0)?; + self.remote_nonce = rlp.val_at(1)?; + self.remote_version = rlp.val_at(2)?; self.state = HandshakeState::StartSession; Ok(()) } @@ -271,13 +271,13 @@ impl Handshake { let (nonce, _) = rest.split_at_mut(32); // E(remote-pubk, S(ecdhe-random, ecdh-shared-secret^nonce) || H(ecdhe-random-pubk) || pubk || nonce || 0x0) - let shared = try!(ecdh::agree(secret, &self.id)); - sig.copy_from_slice(&*try!(sign(self.ecdhe.secret(), &(&shared ^ &self.nonce)))); + let shared = ecdh::agree(secret, &self.id)?; + sig.copy_from_slice(&*sign(self.ecdhe.secret(), &(&shared ^ &self.nonce))?); self.ecdhe.public().sha3_into(hepubk); pubk.copy_from_slice(public); nonce.copy_from_slice(&self.nonce); } - let message = try!(ecies::encrypt(&self.id, &[], &data)); + let message = ecies::encrypt(&self.id, &[], &data)?; self.auth_cipher = message.clone(); self.connection.send(io, message); self.connection.expect(V4_ACK_PACKET_SIZE); @@ -297,7 +297,7 @@ impl Handshake { self.ecdhe.public().copy_to(epubk); self.nonce.copy_to(nonce); } - let message = try!(ecies::encrypt(&self.id, &[], &data)); + let message = ecies::encrypt(&self.id, &[], &data)?; self.ack_cipher = message.clone(); self.connection.send(io, message); self.state = HandshakeState::StartSession; @@ -319,7 +319,7 @@ impl Handshake { let encoded = rlp.drain(); let len = (encoded.len() + ECIES_OVERHEAD) as u16; let prefix = [ (len >> 8) as u8, (len & 0xff) as u8 ]; - let message = try!(ecies::encrypt(&self.id, &prefix, &encoded)); + let message = ecies::encrypt(&self.id, &prefix, &encoded)?; self.ack_cipher.extend_from_slice(&prefix); self.ack_cipher.extend_from_slice(&message); self.connection.send(io, self.ack_cipher.clone()); diff --git a/util/network/src/host.rs b/util/network/src/host.rs index 681773c36..ba966e07c 100644 --- a/util/network/src/host.rs +++ b/util/network/src/host.rs @@ -251,7 +251,7 @@ impl<'s> NetworkContext<'s> { pub fn send_protocol(&self, protocol: ProtocolId, peer: PeerId, packet_id: PacketId, data: Vec) -> Result<(), NetworkError> { let session = self.resolve_session(peer); if let Some(session) = session { - try!(session.lock().send_packet(self.io, protocol, packet_id as u8, &data)); + session.lock().send_packet(self.io, protocol, packet_id as u8, &data)?; } else { trace!(target: "network", "Send: Peer no longer exist") } @@ -387,7 +387,7 @@ impl Host { }; let keys = if let Some(ref secret) = config.use_secret { - try!(KeyPair::from_secret(secret.clone())) + KeyPair::from_secret(secret.clone())? } else { config.config_path.clone().and_then(|ref p| load_key(Path::new(&p))) .map_or_else(|| { @@ -401,8 +401,8 @@ impl Host { }; let path = config.net_config_path.clone(); // Setup the server socket - let tcp_listener = try!(TcpListener::bind(&listen_address)); - listen_address = SocketAddr::new(listen_address.ip(), try!(tcp_listener.local_addr()).port()); + let tcp_listener = TcpListener::bind(&listen_address)?; + listen_address = SocketAddr::new(listen_address.ip(), tcp_listener.local_addr()?.port()); debug!(target: "network", "Listening at {:?}", listen_address); let udp_port = config.udp_port.unwrap_or(listen_address.port()); let local_endpoint = NodeEndpoint { address: listen_address, udp_port: udp_port }; @@ -462,7 +462,7 @@ impl Host { } pub fn add_reserved_node(&self, id: &str) -> Result<(), NetworkError> { - let n = try!(Node::from_str(id)); + let n = Node::from_str(id)?; let entry = NodeEntry { endpoint: n.endpoint.clone(), id: n.id.clone() }; self.reserved_nodes.write().insert(n.id.clone()); @@ -506,7 +506,7 @@ impl Host { } pub fn remove_reserved_node(&self, id: &str) -> Result<(), NetworkError> { - let n = try!(Node::from_str(id)); + let n = Node::from_str(id)?; self.reserved_nodes.write().remove(&n.id); Ok(()) @@ -538,7 +538,7 @@ impl Host { trace!(target: "network", "Disconnecting on shutdown: {}", p); self.kill_connection(p, io, true); } - try!(io.unregister_handler()); + io.unregister_handler()?; Ok(()) } @@ -588,12 +588,12 @@ impl Host { discovery.init_node_list(self.nodes.read().unordered_entries()); discovery.add_node_list(self.nodes.read().unordered_entries()); *self.discovery.lock() = Some(discovery); - try!(io.register_stream(DISCOVERY)); - try!(io.register_timer(DISCOVERY_REFRESH, DISCOVERY_REFRESH_TIMEOUT)); - try!(io.register_timer(DISCOVERY_ROUND, DISCOVERY_ROUND_TIMEOUT)); + io.register_stream(DISCOVERY)?; + io.register_timer(DISCOVERY_REFRESH, DISCOVERY_REFRESH_TIMEOUT)?; + io.register_timer(DISCOVERY_ROUND, DISCOVERY_ROUND_TIMEOUT)?; } - try!(io.register_timer(NODE_TABLE, NODE_TABLE_TIMEOUT)); - try!(io.register_stream(TCP_ACCEPT)); + io.register_timer(NODE_TABLE, NODE_TABLE_TIMEOUT)?; + io.register_stream(TCP_ACCEPT)?; Ok(()) } @@ -737,7 +737,7 @@ impl Host { }); match token { - Some(t) => Ok(try!(From::from(io.register_stream(t)))), + Some(t) => io.register_stream(t).map(|_| ()).map_err(Into::into), None => { debug!(target: "network", "Max sessions reached"); Ok(()) diff --git a/util/network/src/node_table.rs b/util/network/src/node_table.rs index 3474ce962..8e95991e2 100644 --- a/util/network/src/node_table.rs +++ b/util/network/src/node_table.rs @@ -64,10 +64,10 @@ impl NodeEndpoint { } pub fn from_rlp(rlp: &UntrustedRlp) -> Result { - let tcp_port = try!(rlp.val_at::(2)); - let udp_port = try!(rlp.val_at::(1)); - let addr_bytes = try!(try!(rlp.at(0)).data()); - let address = try!(match addr_bytes.len() { + let tcp_port = rlp.val_at::(2)?; + let udp_port = rlp.val_at::(1)?; + let addr_bytes = rlp.at(0)?.data()?; + let address = match addr_bytes.len() { 4 => Ok(SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(addr_bytes[0], addr_bytes[1], addr_bytes[2], addr_bytes[3]), tcp_port))), 16 => unsafe { let o: *const u16 = mem::transmute(addr_bytes.as_ptr()); @@ -75,7 +75,7 @@ impl NodeEndpoint { Ok(SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::new(o[0], o[1], o[2], o[3], o[4], o[5], o[6], o[7]), tcp_port, 0, 0))) }, _ => Err(DecoderError::RlpInconsistentLengthAndData) - }); + }?; Ok(NodeEndpoint { address: address, udp_port: udp_port }) } @@ -153,9 +153,9 @@ impl Node { impl Display for Node { fn fmt(&self, f: &mut Formatter) -> fmt::Result { if self.endpoint.udp_port != self.endpoint.address.port() { - try!(write!(f, "enode://{}@{}+{}", self.id.hex(), self.endpoint.address, self.endpoint.udp_port)); + write!(f, "enode://{}@{}+{}", self.id.hex(), self.endpoint.address, self.endpoint.udp_port)?; } else { - try!(write!(f, "enode://{}@{}", self.id.hex(), self.endpoint.address)); + write!(f, "enode://{}@{}", self.id.hex(), self.endpoint.address)?; } Ok(()) } @@ -165,10 +165,10 @@ impl FromStr for Node { type Err = NetworkError; fn from_str(s: &str) -> Result { let (id, endpoint) = if s.len() > 136 && &s[0..8] == "enode://" && &s[136..137] == "@" { - (try!(s[8..136].parse().map_err(UtilError::from)), try!(NodeEndpoint::from_str(&s[137..]))) + (s[8..136].parse().map_err(UtilError::from)?, NodeEndpoint::from_str(&s[137..])?) } else { - (NodeId::new(), try!(NodeEndpoint::from_str(s))) + (NodeId::new(), NodeEndpoint::from_str(s)?) }; Ok(Node { diff --git a/util/network/src/service.rs b/util/network/src/service.rs index 766b87750..b1157fa58 100644 --- a/util/network/src/service.rs +++ b/util/network/src/service.rs @@ -56,7 +56,7 @@ impl NetworkService { pub fn new(config: NetworkConfiguration) -> Result { let host_handler = Arc::new(HostHandler { public_url: RwLock::new(None) }); let panic_handler = PanicHandler::new_in_arc(); - let io_service = try!(IoService::::start()); + let io_service = IoService::::start()?; panic_handler.forward_from(&io_service); let stats = Arc::new(NetworkStats::new()); @@ -74,12 +74,12 @@ impl NetworkService { /// Regiter a new protocol handler with the event loop. pub fn register_protocol(&self, handler: Arc, protocol: ProtocolId, packet_count: u8, versions: &[u8]) -> Result<(), NetworkError> { - try!(self.io_service.send_message(NetworkIoMessage::AddHandler { + self.io_service.send_message(NetworkIoMessage::AddHandler { handler: handler, protocol: protocol, versions: versions.to_vec(), packet_count: packet_count, - })); + })?; Ok(()) } @@ -119,13 +119,13 @@ impl NetworkService { pub fn start(&self) -> Result<(), NetworkError> { let mut host = self.host.write(); if host.is_none() { - let h = Arc::new(try!(Host::new(self.config.clone(), self.stats.clone()))); - try!(self.io_service.register_handler(h.clone())); + let h = Arc::new(Host::new(self.config.clone(), self.stats.clone())?); + self.io_service.register_handler(h.clone())?; *host = Some(h); } if self.host_handler.public_url.read().is_none() { - try!(self.io_service.register_handler(self.host_handler.clone())); + self.io_service.register_handler(self.host_handler.clone())?; } Ok(()) @@ -136,7 +136,7 @@ impl NetworkService { let mut host = self.host.write(); if let Some(ref host) = *host { let io = IoContext::new(self.io_service.channel(), 0); //TODO: take token id from host - try!(host.stop(&io)); + host.stop(&io)?; } *host = None; Ok(()) diff --git a/util/network/src/session.rs b/util/network/src/session.rs index d19d330c9..14cb5a65e 100644 --- a/util/network/src/session.rs +++ b/util/network/src/session.rs @@ -118,7 +118,7 @@ pub struct PeerCapabilityInfo { impl Decodable for PeerCapabilityInfo { fn decode(decoder: &D) -> Result where D: Decoder { let c = decoder.as_rlp(); - let p: Vec = try!(c.val_at(0)); + let p: Vec = c.val_at(0)?; if p.len() != 3 { return Err(DecoderError::Custom("Invalid subprotocol string length. Should be 3")); } @@ -126,7 +126,7 @@ impl Decodable for PeerCapabilityInfo { p2.clone_from_slice(&p); Ok(PeerCapabilityInfo { protocol: p2, - version: try!(c.val_at(1)) + version: c.val_at(1)? }) } } @@ -180,7 +180,7 @@ impl Session { let originated = id.is_some(); let mut handshake = Handshake::new(token, id, socket, nonce, stats).expect("Can't create handshake"); let local_addr = handshake.connection.local_addr_str(); - try!(handshake.start(io, host, originated)); + handshake.start(io, host, originated)?; Ok(Session { state: State::Handshake(handshake), had_hello: false, @@ -206,13 +206,13 @@ impl Session { let connection = if let State::Handshake(ref mut h) = self.state { self.info.id = Some(h.id.clone()); self.info.remote_address = h.connection.remote_addr_str(); - try!(EncryptedConnection::new(h)) + EncryptedConnection::new(h)? } else { panic!("Unexpected state"); }; self.state = State::Session(connection); - try!(self.write_hello(io, host)); - try!(self.send_ping(io)); + self.write_hello(io, host)?; + self.send_ping(io)?; Ok(()) } @@ -265,23 +265,23 @@ impl Session { let mut packet_data = None; match self.state { State::Handshake(ref mut h) => { - try!(h.readable(io, host)); + h.readable(io, host)?; if h.done() { create_session = true; } } State::Session(ref mut c) => { - match try!(c.readable(io)) { + match c.readable(io)? { data @ Some(_) => packet_data = data, None => return Ok(SessionData::None) } } } if let Some(data) = packet_data { - return Ok(try!(self.read_packet(io, data, host))); + return Ok(self.read_packet(io, data, host)?); } if create_session { - try!(self.complete_handshake(io, host)); + self.complete_handshake(io, host)?; io.update_registration(self.token()).unwrap_or_else(|e| debug!(target: "network", "Token registration error: {:?}", e)); } Ok(SessionData::None) @@ -310,19 +310,19 @@ impl Session { if self.expired() { return Ok(()); } - try!(self.connection().register_socket(reg, event_loop)); + self.connection().register_socket(reg, event_loop)?; Ok(()) } /// Update registration with the event loop. Should be called at the end of the IO handler. pub fn update_socket(&self, reg:Token, event_loop: &mut EventLoop) -> Result<(), NetworkError> { - try!(self.connection().update_socket(reg, event_loop)); + self.connection().update_socket(reg, event_loop)?; Ok(()) } /// Delete registration pub fn deregister_socket(&self, event_loop: &mut EventLoop) -> Result<(), NetworkError> { - try!(self.connection().deregister_socket(event_loop)); + self.connection().deregister_socket(event_loop)?; Ok(()) } @@ -400,19 +400,19 @@ impl Session { match packet_id { PACKET_HELLO => { let rlp = UntrustedRlp::new(&packet.data[1..]); //TODO: validate rlp expected size - try!(self.read_hello(io, &rlp, host)); + self.read_hello(io, &rlp, host)?; Ok(SessionData::Ready) }, PACKET_DISCONNECT => { let rlp = UntrustedRlp::new(&packet.data[1..]); - let reason: u8 = try!(rlp.val_at(0)); + let reason: u8 = rlp.val_at(0)?; if self.had_hello { debug!("Disconnected: {}: {:?}", self.token(), DisconnectReason::from_u8(reason)); } Err(From::from(NetworkError::Disconnect(DisconnectReason::from_u8(reason)))) } PACKET_PING => { - try!(self.send_pong(io)); + self.send_pong(io)?; Ok(SessionData::Continue) }, PACKET_PONG => { @@ -471,10 +471,10 @@ impl Session { fn read_hello(&mut self, io: &IoContext, rlp: &UntrustedRlp, host: &HostInfo) -> Result<(), NetworkError> where Message: Send + Sync + Clone { - let protocol = try!(rlp.val_at::(0)); - let client_version = try!(rlp.val_at::(1)); - let peer_caps = try!(rlp.val_at::>(2)); - let id = try!(rlp.val_at::(4)); + let protocol = rlp.val_at::(0)?; + let client_version = rlp.val_at::(1)?; + let peer_caps = rlp.val_at::>(2)?; + let id = rlp.val_at::(4)?; // Intersect with host capabilities // Leave only highset mutually supported capability version @@ -530,14 +530,14 @@ impl Session { /// Senf ping packet pub fn send_ping(&mut self, io: &IoContext) -> Result<(), NetworkError> where Message: Send + Sync + Clone { - try!(self.send(io, try!(Session::prepare(PACKET_PING)))); + self.send(io, Session::prepare(PACKET_PING)?)?; self.ping_time_ns = time::precise_time_ns(); self.pong_time_ns = None; Ok(()) } fn send_pong(&mut self, io: &IoContext) -> Result<(), NetworkError> where Message: Send + Sync + Clone { - self.send(io, try!(Session::prepare(PACKET_PONG))) + self.send(io, Session::prepare(PACKET_PONG)?) } /// Disconnect this session @@ -565,7 +565,7 @@ impl Session { warn!(target:"network", "Unexpected send request"); }, State::Session(ref mut s) => { - try!(s.send_packet(io, &rlp.out())) + s.send_packet(io, &rlp.out())? }, } Ok(()) diff --git a/util/rlp/src/untrusted_rlp.rs b/util/rlp/src/untrusted_rlp.rs index 5bb969046..1fb94a17b 100644 --- a/util/rlp/src/untrusted_rlp.rs +++ b/util/rlp/src/untrusted_rlp.rs @@ -64,7 +64,7 @@ fn calculate_payload_info(header_bytes: &[u8], len_of_len: usize) -> Result (), } if header_bytes.len() < header_len { return Err(DecoderError::RlpIsTooShort); } - let value_len = try!(usize::from_bytes(&header_bytes[1..header_len])); + let value_len = usize::from_bytes(&header_bytes[1..header_len])?; Ok(PayloadInfo::new(header_len, value_len)) } @@ -129,11 +129,11 @@ impl<'a> fmt::Display for UntrustedRlp<'a> { Ok(Prototype::Null) => write!(f, "null"), Ok(Prototype::Data(_)) => write!(f, "\"0x{}\"", self.data().unwrap().to_hex()), Ok(Prototype::List(len)) => { - try!(write!(f, "[")); + write!(f, "[")?; for i in 0..len-1 { - try!(write!(f, "{}, ", self.at(i).unwrap())); + write!(f, "{}, ", self.at(i).unwrap())?; } - try!(write!(f, "{}", self.at(len - 1).unwrap())); + write!(f, "{}", self.at(len - 1).unwrap())?; write!(f, "]") }, Err(err) => write!(f, "{:?}", err) @@ -177,7 +177,7 @@ impl<'a, 'view> View<'a, 'view> for UntrustedRlp<'a> where 'a: 'view { } fn data(&'view self) -> Self::Data { - let pi = try!(BasicDecoder::payload_info(self.bytes)); + let pi = BasicDecoder::payload_info(self.bytes)?; Ok(&self.bytes[pi.header_len..(pi.header_len + pi.value_len)]) } @@ -212,18 +212,18 @@ impl<'a, 'view> View<'a, 'view> for UntrustedRlp<'a> where 'a: 'view { // current search index, otherwise move to beginning of list let c = self.offset_cache.get(); let (mut bytes, to_skip) = match c.index <= index { - true => (try!(UntrustedRlp::consume(self.bytes, c.offset)), index - c.index), - false => (try!(self.consume_list_prefix()), index), + true => (UntrustedRlp::consume(self.bytes, c.offset)?, index - c.index), + false => (self.consume_list_prefix()?, index), }; // skip up to x items - bytes = try!(UntrustedRlp::consume_items(bytes, to_skip)); + bytes = UntrustedRlp::consume_items(bytes, to_skip)?; // update the cache self.offset_cache.set(OffsetCache::new(index, self.bytes.len() - bytes.len())); // construct new rlp - let found = try!(BasicDecoder::payload_info(bytes)); + let found = BasicDecoder::payload_info(bytes)?; Ok(UntrustedRlp::new(&bytes[0..found.header_len + found.value_len])) } @@ -266,15 +266,15 @@ impl<'a, 'view> View<'a, 'view> for UntrustedRlp<'a> where 'a: 'view { } fn val_at(&self, index: usize) -> Result where T: RlpDecodable { - try!(self.at(index)).as_val() + self.at(index)?.as_val() } } impl<'a> UntrustedRlp<'a> { /// consumes first found prefix fn consume_list_prefix(&self) -> Result<&'a [u8], DecoderError> { - let item = try!(BasicDecoder::payload_info(self.bytes)); - let bytes = try!(UntrustedRlp::consume(self.bytes, item.header_len)); + let item = BasicDecoder::payload_info(self.bytes)?; + let bytes = UntrustedRlp::consume(self.bytes, item.header_len)?; Ok(bytes) } @@ -282,8 +282,8 @@ impl<'a> UntrustedRlp<'a> { fn consume_items(bytes: &'a [u8], items: usize) -> Result<&'a [u8], DecoderError> { let mut result = bytes; for _ in 0..items { - let i = try!(BasicDecoder::payload_info(result)); - result = try!(UntrustedRlp::consume(result, (i.header_len + i.value_len))); + let i = BasicDecoder::payload_info(result)?; + result = UntrustedRlp::consume(result, (i.header_len + i.value_len))?; } Ok(result) } @@ -340,7 +340,7 @@ impl<'a> BasicDecoder<'a> { /// Return first item info. fn payload_info(bytes: &[u8]) -> Result { - let item = try!(PayloadInfo::from(bytes)); + let item = PayloadInfo::from(bytes)?; match item.header_len.checked_add(item.value_len) { Some(x) if x <= bytes.len() => Ok(item), _ => Err(DecoderError::RlpIsTooShort), @@ -358,7 +358,7 @@ impl<'a> Decoder for BasicDecoder<'a> { // RLP is too short. None => Err(DecoderError::RlpIsTooShort), // Single byte value. - Some(l @ 0...0x7f) => Ok(try!(f(&[l]))), + Some(l @ 0...0x7f) => Ok(f(&[l])?), // 0-55 bytes Some(l @ 0x80...0xb7) => { let last_index_of = 1 + l as usize - 0x80; @@ -369,7 +369,7 @@ impl<'a> Decoder for BasicDecoder<'a> { if l == 0x81 && d[0] < 0x80 { return Err(DecoderError::RlpInvalidIndirection); } - Ok(try!(f(d))) + Ok(f(d)?) }, // Longer than 55 bytes. Some(l @ 0xb8...0xbf) => { @@ -378,13 +378,13 @@ impl<'a> Decoder for BasicDecoder<'a> { if bytes.len() < begin_of_value { return Err(DecoderError::RlpInconsistentLengthAndData); } - let len = try!(usize::from_bytes(&bytes[1..begin_of_value])); + let len = usize::from_bytes(&bytes[1..begin_of_value])?; let last_index_of_value = begin_of_value + len; if bytes.len() < last_index_of_value { return Err(DecoderError::RlpInconsistentLengthAndData); } - Ok(try!(f(&bytes[begin_of_value..last_index_of_value]))) + Ok(f(&bytes[begin_of_value..last_index_of_value])?) } // We are reading value, not a list! _ => Err(DecoderError::RlpExpectedToBeData) @@ -402,7 +402,7 @@ impl<'a> Decoder for BasicDecoder<'a> { impl Decodable for T where T: FromBytes { fn decode(decoder: &D) -> Result where D: Decoder { - decoder.read_value(&|bytes: &[u8]| Ok(try!(T::from_bytes(bytes)))) + decoder.read_value(&|bytes: &[u8]| Ok(T::from_bytes(bytes)?)) } } @@ -436,7 +436,7 @@ macro_rules! impl_array_decodable { } for i in 0..decoders.item_count() { - result[i] = try!(T::decode(&BasicDecoder::new(try!(decoders.at(i))))); + result[i] = T::decode(&BasicDecoder::new(decoders.at(i)?))?; } Ok(result) @@ -484,7 +484,7 @@ impl FromBytes for DecodableU8 { impl RlpDecodable for u8 { fn decode(decoder: &D) -> Result where D: Decoder { - let u: DecodableU8 = try!(Decodable::decode(decoder)); + let u: DecodableU8 = Decodable::decode(decoder)?; Ok(u.0) } } diff --git a/util/src/bytes.rs b/util/src/bytes.rs index fd0f42c0b..0fdd692a9 100644 --- a/util/src/bytes.rs +++ b/util/src/bytes.rs @@ -30,8 +30,8 @@ impl<'a> fmt::Debug for PrettySlice<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { for i in 0..self.0.len() { match i > 0 { - true => { try!(write!(f, "·{:02x}", self.0[i])); }, - false => { try!(write!(f, "{:02x}", self.0[i])); }, + true => { write!(f, "·{:02x}", self.0[i])?; }, + false => { write!(f, "{:02x}", self.0[i])?; }, } } Ok(()) @@ -41,7 +41,7 @@ impl<'a> fmt::Debug for PrettySlice<'a> { impl<'a> fmt::Display for PrettySlice<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { for i in 0..self.0.len() { - try!(write!(f, "{:02x}", self.0[i])); + write!(f, "{:02x}", self.0[i])?; } Ok(()) } diff --git a/util/src/journaldb/archivedb.rs b/util/src/journaldb/archivedb.rs index accc28ffd..29c0fd708 100644 --- a/util/src/journaldb/archivedb.rs +++ b/util/src/journaldb/archivedb.rs @@ -159,7 +159,7 @@ impl JournalDB for ArchiveDB { for i in self.overlay.drain() { let (key, (value, rc)) = i; if rc > 0 { - if try!(self.backing.get(self.column, &key)).is_some() { + if self.backing.get(self.column, &key)?.is_some() { return Err(BaseDataError::AlreadyExists(key).into()); } batch.put(self.column, &key, &value); @@ -167,7 +167,7 @@ impl JournalDB for ArchiveDB { } if rc < 0 { assert!(rc == -1); - if try!(self.backing.get(self.column, &key)).is_none() { + if self.backing.get(self.column, &key)?.is_none() { return Err(BaseDataError::NegativelyReferencedHash(key).into()); } batch.delete(self.column, &key); diff --git a/util/src/journaldb/earlymergedb.rs b/util/src/journaldb/earlymergedb.rs index 26d1576ce..3457f0e0b 100644 --- a/util/src/journaldb/earlymergedb.rs +++ b/util/src/journaldb/earlymergedb.rs @@ -391,14 +391,14 @@ impl JournalDB for EarlyMergeDB { let mut index = 0usize; let mut last; - while try!(self.backing.get(self.column, { + while self.backing.get(self.column, { let mut r = RlpStream::new_list(3); r.append(&now); r.append(&index); r.append(&&PADDING[..]); last = r.drain(); &last - })).is_some() { + })?.is_some() { index += 1; } @@ -461,14 +461,14 @@ impl JournalDB for EarlyMergeDB { let mut index = 0usize; let mut last; - while let Some(rlp_data) = try!(self.backing.get(self.column, { + while let Some(rlp_data) = self.backing.get(self.column, { let mut r = RlpStream::new_list(3); r.append(&end_era); r.append(&index); r.append(&&PADDING[..]); last = r.drain(); &last - })) { + })? { let rlp = Rlp::new(&rlp_data); let inserts: Vec = rlp.val_at(1); @@ -525,13 +525,13 @@ impl JournalDB for EarlyMergeDB { match rc { 0 => {} 1 => { - if try!(self.backing.get(self.column, &key)).is_some() { + if self.backing.get(self.column, &key)?.is_some() { return Err(BaseDataError::AlreadyExists(key).into()); } batch.put(self.column, &key, &value) } -1 => { - if try!(self.backing.get(self.column, &key)).is_none() { + if self.backing.get(self.column, &key)?.is_none() { return Err(BaseDataError::NegativelyReferencedHash(key).into()); } batch.delete(self.column, &key) diff --git a/util/src/journaldb/overlayrecentdb.rs b/util/src/journaldb/overlayrecentdb.rs index a80fedc79..db320f07d 100644 --- a/util/src/journaldb/overlayrecentdb.rs +++ b/util/src/journaldb/overlayrecentdb.rs @@ -348,13 +348,13 @@ impl JournalDB for OverlayRecentDB { match rc { 0 => {} 1 => { - if cfg!(debug_assertions) && try!(self.backing.get(self.column, &key)).is_some() { + if cfg!(debug_assertions) && self.backing.get(self.column, &key)?.is_some() { return Err(BaseDataError::AlreadyExists(key).into()); } batch.put(self.column, &key, &value) } -1 => { - if cfg!(debug_assertions) && try!(self.backing.get(self.column, &key)).is_none() { + if cfg!(debug_assertions) && self.backing.get(self.column, &key)?.is_none() { return Err(BaseDataError::NegativelyReferencedHash(key).into()); } batch.delete(self.column, &key) diff --git a/util/src/journaldb/refcounteddb.rs b/util/src/journaldb/refcounteddb.rs index e8a4e342d..26e8c91e5 100644 --- a/util/src/journaldb/refcounteddb.rs +++ b/util/src/journaldb/refcounteddb.rs @@ -127,14 +127,14 @@ impl JournalDB for RefCountedDB { let mut index = 0usize; let mut last; - while try!(self.backing.get(self.column, { + while self.backing.get(self.column, { let mut r = RlpStream::new_list(3); r.append(&now); r.append(&index); r.append(&&PADDING[..]); last = r.drain(); &last - })).is_some() { + })?.is_some() { index += 1; } @@ -164,14 +164,14 @@ impl JournalDB for RefCountedDB { let mut index = 0usize; let mut last; while let Some(rlp_data) = { - try!(self.backing.get(self.column, { + self.backing.get(self.column, { let mut r = RlpStream::new_list(3); r.append(&end_era); r.append(&index); r.append(&&PADDING[..]); last = r.drain(); &last - })) + })? } { let rlp = Rlp::new(&rlp_data); let our_id: H256 = rlp.val_at(0); @@ -184,7 +184,7 @@ impl JournalDB for RefCountedDB { index += 1; } - let r = try!(self.forward.commit_to_batch(batch)); + let r = self.forward.commit_to_batch(batch)?; Ok(r) } diff --git a/util/src/journaldb/traits.rs b/util/src/journaldb/traits.rs index 90063cd91..e32591d96 100644 --- a/util/src/journaldb/traits.rs +++ b/util/src/journaldb/traits.rs @@ -74,10 +74,10 @@ pub trait JournalDB: HashDB { #[cfg(test)] fn commit_batch(&mut self, now: u64, id: &H256, end: Option<(u64, H256)>) -> Result { let mut batch = self.backing().transaction(); - let mut ops = try!(self.journal_under(&mut batch, now, id)); + let mut ops = self.journal_under(&mut batch, now, id)?; if let Some((end_era, canon_id)) = end { - ops += try!(self.mark_canonical(&mut batch, end_era, &canon_id)); + ops += self.mark_canonical(&mut batch, end_era, &canon_id)?; } let result = self.backing().write(batch).map(|_| ops).map_err(Into::into); @@ -89,7 +89,7 @@ pub trait JournalDB: HashDB { #[cfg(test)] fn inject_batch(&mut self) -> Result { let mut batch = self.backing().transaction(); - let res = try!(self.inject(&mut batch)); + let res = self.inject(&mut batch)?; self.backing().write(batch).map(|_| res).map_err(Into::into) } } diff --git a/util/src/kvdb.rs b/util/src/kvdb.rs index 916ee44ae..067e29f4c 100644 --- a/util/src/kvdb.rs +++ b/util/src/kvdb.rs @@ -295,10 +295,10 @@ impl Database { let mut opts = Options::new(); if let Some(rate_limit) = config.compaction.write_rate_limit { - try!(opts.set_parsed_options(&format!("rate_limiter_bytes_per_sec={}", rate_limit))); + opts.set_parsed_options(&format!("rate_limiter_bytes_per_sec={}", rate_limit))?; } - try!(opts.set_parsed_options(&format!("max_total_wal_size={}", 64 * 1024 * 1024))); - try!(opts.set_parsed_options("verify_checksums_in_compaction=0")); + opts.set_parsed_options(&format!("max_total_wal_size={}", 64 * 1024 * 1024))?; + opts.set_parsed_options("verify_checksums_in_compaction=0")?; opts.set_max_open_files(config.max_open_files); opts.create_if_missing(true); opts.set_use_fsync(false); @@ -355,7 +355,7 @@ impl Database { // retry and create CFs match DB::open_cf(&opts, path, &[], &[]) { Ok(mut db) => { - cfs = try!(cfnames.iter().enumerate().map(|(i, n)| db.create_cf(n, &cf_options[i])).collect()); + cfs = cfnames.iter().enumerate().map(|(i, n)| db.create_cf(n, &cf_options[i])).collect::>()?; Ok(db) }, err @ Err(_) => err, @@ -371,11 +371,11 @@ impl Database { Err(ref s) if s.starts_with("Corruption:") => { info!("{}", s); info!("Attempting DB repair for {}", path); - try!(DB::repair(&opts, path)); + DB::repair(&opts, path)?; match cfnames.is_empty() { - true => try!(DB::open(&opts, path)), - false => try!(DB::open_cf(&opts, path, &cfnames, &cf_options)) + true => DB::open(&opts, path)?, + false => DB::open_cf(&opts, path, &cfnames, &cf_options)? } }, Err(s) => { return Err(s); } @@ -437,31 +437,31 @@ impl Database { match **state { KeyState::Delete => { if c > 0 { - try!(batch.delete_cf(cfs[c - 1], &key)); + batch.delete_cf(cfs[c - 1], &key)?; } else { - try!(batch.delete(&key)); + batch.delete(&key)?; } }, KeyState::Insert(ref value) => { if c > 0 { - try!(batch.put_cf(cfs[c - 1], &key, value)); + batch.put_cf(cfs[c - 1], &key, value)?; } else { - try!(batch.put(&key, &value)); + batch.put(&key, &value)?; } }, KeyState::InsertCompressed(ref value) => { let compressed = UntrustedRlp::new(&value).compress(RlpType::Blocks); if c > 0 { - try!(batch.put_cf(cfs[c - 1], &key, &compressed)); + batch.put_cf(cfs[c - 1], &key, &compressed)?; } else { - try!(batch.put(&key, &value)); + batch.put(&key, &value)?; } } } } } } - try!(db.write_opt(batch, &self.write_opts)); + db.write_opt(batch, &self.write_opts)?; for column in self.flushing.write().iter_mut() { column.clear(); column.shrink_to_fit(); @@ -496,14 +496,14 @@ impl Database { for op in ops { match op { DBOp::Insert { col, key, value } => { - try!(col.map_or_else(|| batch.put(&key, &value), |c| batch.put_cf(cfs[c as usize], &key, &value))) + col.map_or_else(|| batch.put(&key, &value), |c| batch.put_cf(cfs[c as usize], &key, &value))? }, DBOp::InsertCompressed { col, key, value } => { let compressed = UntrustedRlp::new(&value).compress(RlpType::Blocks); - try!(col.map_or_else(|| batch.put(&key, &compressed), |c| batch.put_cf(cfs[c as usize], &key, &compressed))) + col.map_or_else(|| batch.put(&key, &compressed), |c| batch.put_cf(cfs[c as usize], &key, &compressed))? }, DBOp::Delete { col, key } => { - try!(col.map_or_else(|| batch.delete(&key), |c| batch.delete_cf(cfs[c as usize], &key))) + col.map_or_else(|| batch.delete(&key), |c| batch.delete_cf(cfs[c as usize], &key))? }, } } @@ -598,20 +598,20 @@ impl Database { Ok(_) => { // clean up the backup. if existed { - try!(fs::remove_dir_all(&backup_db)); + fs::remove_dir_all(&backup_db)?; } } Err(e) => { // restore the backup. if existed { - try!(fs::rename(&backup_db, &self.path)); + fs::rename(&backup_db, &self.path)?; } return Err(e.into()) } } // reopen the database and steal handles into self - let db = try!(Self::open(&self.config, &self.path)); + let db = Self::open(&self.config, &self.path)?; *self.db.write() = mem::replace(&mut *db.db.write(), None); *self.overlay.write() = mem::replace(&mut *db.overlay.write(), Vec::new()); *self.flushing.write() = mem::replace(&mut *db.flushing.write(), Vec::new()); diff --git a/util/src/migration/mod.rs b/util/src/migration/mod.rs index af1eda192..3ce1cfa0b 100644 --- a/util/src/migration/mod.rs +++ b/util/src/migration/mod.rs @@ -65,7 +65,7 @@ impl Batch { pub fn insert(&mut self, key: Vec, value: Vec, dest: &mut Database) -> Result<(), Error> { self.inner.insert(key, value); if self.inner.len() == self.batch_size { - try!(self.commit(dest)); + self.commit(dest)?; } Ok(()) } @@ -154,7 +154,7 @@ impl Migration for T { for (key, value) in source.iter(col) { if let Some((key, value)) = self.simple_migrate(key.to_vec(), value.to_vec()) { - try!(batch.insert(key, value, dest)); + batch.insert(key, value, dest)?; } } @@ -247,8 +247,8 @@ impl Manager { let mut temp_path = temp_idx.path(&db_root); // start with the old db. - let old_path_str = try!(old_path.to_str().ok_or(Error::MigrationImpossible)); - let mut cur_db = Arc::new(try!(Database::open(&db_config, old_path_str).map_err(Error::Custom))); + let old_path_str = old_path.to_str().ok_or(Error::MigrationImpossible)?; + let mut cur_db = Arc::new(Database::open(&db_config, old_path_str).map_err(Error::Custom)?); for migration in migrations { trace!(target: "migration", "starting migration to version {}", migration.version()); @@ -258,17 +258,17 @@ impl Manager { // open the target temporary database. temp_path = temp_idx.path(&db_root); - let temp_path_str = try!(temp_path.to_str().ok_or(Error::MigrationImpossible)); - let mut new_db = try!(Database::open(&db_config, temp_path_str).map_err(Error::Custom)); + let temp_path_str = temp_path.to_str().ok_or(Error::MigrationImpossible)?; + let mut new_db = Database::open(&db_config, temp_path_str).map_err(Error::Custom)?; // perform the migration from cur_db to new_db. match current_columns { // migrate only default column - None => try!(migration.migrate(cur_db.clone(), &config, &mut new_db, None)), + None => migration.migrate(cur_db.clone(), &config, &mut new_db, None)?, Some(v) => { // Migrate all columns in previous DB for col in 0..v { - try!(migration.migrate(cur_db.clone(), &config, &mut new_db, Some(col))) + migration.migrate(cur_db.clone(), &config, &mut new_db, Some(col))? } } } diff --git a/util/src/migration/tests.rs b/util/src/migration/tests.rs index 49804976b..5b621fc69 100644 --- a/util/src/migration/tests.rs +++ b/util/src/migration/tests.rs @@ -95,12 +95,12 @@ impl Migration for AddsColumn { let mut batch = Batch::new(config, col); for (key, value) in source.iter(col) { - try!(batch.insert(key.to_vec(), value.to_vec(), dest)); + batch.insert(key.to_vec(), value.to_vec(), dest)?; } if col == Some(1) { - try!(batch.insert(vec![1, 2, 3], vec![4, 5, 6], dest)); + batch.insert(vec![1, 2, 3], vec![4, 5, 6], dest)?; } batch.commit(dest) diff --git a/util/src/nibbleslice.rs b/util/src/nibbleslice.rs index 15096bbd5..071e747a1 100644 --- a/util/src/nibbleslice.rs +++ b/util/src/nibbleslice.rs @@ -201,8 +201,8 @@ impl<'a> fmt::Debug for NibbleSlice<'a> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { for i in 0..self.len() { match i { - 0 => try!(write!(f, "{:01x}", self.at(i))), - _ => try!(write!(f, "'{:01x}", self.at(i))), + 0 => write!(f, "{:01x}", self.at(i))?, + _ => write!(f, "'{:01x}", self.at(i))?, } } Ok(()) diff --git a/util/src/overlaydb.rs b/util/src/overlaydb.rs index aef68a5eb..5df39a36a 100644 --- a/util/src/overlaydb.rs +++ b/util/src/overlaydb.rs @@ -58,7 +58,7 @@ impl OverlayDB { #[cfg(test)] pub fn commit(&mut self) -> Result { let mut batch = self.backing.transaction(); - let res = try!(self.commit_to_batch(&mut batch)); + let res = self.commit_to_batch(&mut batch)?; self.backing.write(batch).map(|_| res).map_err(|e| e.into()) } diff --git a/util/src/sha3.rs b/util/src/sha3.rs index 7bec5e3db..58f740ac4 100644 --- a/util/src/sha3.rs +++ b/util/src/sha3.rs @@ -76,7 +76,7 @@ pub fn sha3(r: &mut io::BufRead) -> Result { // read file loop { - let some = try!(r.read(&mut input)); + let some = r.read(&mut input)?; if some == 0 { break; } diff --git a/util/src/snappy.rs b/util/src/snappy.rs index e1318d837..142dcadb0 100644 --- a/util/src/snappy.rs +++ b/util/src/snappy.rs @@ -127,7 +127,7 @@ pub fn decompress(input: &[u8]) -> Result, InvalidInput> { /// Will error if the input buffer is not snappy-compressed. /// Otherwise, returns the length of the decompressed data. pub fn decompress_into(input: &[u8], output: &mut Vec) -> Result { - let mut len = try!(decompressed_len(input)); + let mut len = decompressed_len(input)?; if output.len() < len { output.resize(len, 0); diff --git a/util/src/trie/fatdb.rs b/util/src/trie/fatdb.rs index 7f350828b..f8d47bb38 100644 --- a/util/src/trie/fatdb.rs +++ b/util/src/trie/fatdb.rs @@ -33,7 +33,7 @@ impl<'db> FatDB<'db> { /// This guarantees the trie is built correctly. pub fn new(db: &'db HashDB, root: &'db H256) -> super::Result { let fatdb = FatDB { - raw: try!(TrieDB::new(db, root)) + raw: TrieDB::new(db, root)? }; Ok(fatdb) @@ -75,7 +75,7 @@ impl<'db> FatDBIterator<'db> { /// Creates new iterator. pub fn new(trie: &'db TrieDB) -> super::Result { Ok(FatDBIterator { - trie_iterator: try!(TrieDBIterator::new(trie)), + trie_iterator: TrieDBIterator::new(trie)?, trie: trie, }) } diff --git a/util/src/trie/fatdbmut.rs b/util/src/trie/fatdbmut.rs index 25f0849d0..ceed14bab 100644 --- a/util/src/trie/fatdbmut.rs +++ b/util/src/trie/fatdbmut.rs @@ -39,7 +39,7 @@ impl<'db> FatDBMut<'db> { /// /// Returns an error if root does not exist. pub fn from_existing(db: &'db mut HashDB, root: &'db mut H256) -> super::Result { - Ok(FatDBMut { raw: try!(TrieDBMut::from_existing(db, root)) }) + Ok(FatDBMut { raw: TrieDBMut::from_existing(db, root)? }) } /// Get the backing database. @@ -78,7 +78,7 @@ impl<'db> TrieMut for FatDBMut<'db> { fn insert(&mut self, key: &[u8], value: &[u8]) -> super::Result<()> { let hash = key.sha3(); - try!(self.raw.insert(&hash, value)); + self.raw.insert(&hash, value)?; let db = self.raw.db_mut(); db.emplace(Self::to_aux_key(&hash), DBValue::from_slice(key)); Ok(()) diff --git a/util/src/trie/mod.rs b/util/src/trie/mod.rs index 7245e2d5d..6a0e588c3 100644 --- a/util/src/trie/mod.rs +++ b/util/src/trie/mod.rs @@ -216,9 +216,9 @@ impl TrieFactory { /// Create new immutable instance of Trie. pub fn readonly<'db>(&self, db: &'db HashDB, root: &'db H256) -> Result> { match self.spec { - TrieSpec::Generic => Ok(TrieKinds::Generic(try!(TrieDB::new(db, root)))), - TrieSpec::Secure => Ok(TrieKinds::Secure(try!(SecTrieDB::new(db, root)))), - TrieSpec::Fat => Ok(TrieKinds::Fat(try!(FatDB::new(db, root)))), + TrieSpec::Generic => Ok(TrieKinds::Generic(TrieDB::new(db, root)?)), + TrieSpec::Secure => Ok(TrieKinds::Secure(SecTrieDB::new(db, root)?)), + TrieSpec::Fat => Ok(TrieKinds::Fat(FatDB::new(db, root)?)), } } @@ -234,9 +234,9 @@ impl TrieFactory { /// Create new mutable instance of trie and check for errors. pub fn from_existing<'db>(&self, db: &'db mut HashDB, root: &'db mut H256) -> Result> { match self.spec { - TrieSpec::Generic => Ok(Box::new(try!(TrieDBMut::from_existing(db, root)))), - TrieSpec::Secure => Ok(Box::new(try!(SecTrieDBMut::from_existing(db, root)))), - TrieSpec::Fat => Ok(Box::new(try!(FatDBMut::from_existing(db, root)))), + TrieSpec::Generic => Ok(Box::new(TrieDBMut::from_existing(db, root)?)), + TrieSpec::Secure => Ok(Box::new(SecTrieDBMut::from_existing(db, root)?)), + TrieSpec::Fat => Ok(Box::new(FatDBMut::from_existing(db, root)?)), } } diff --git a/util/src/trie/sectriedb.rs b/util/src/trie/sectriedb.rs index 4df12cde3..e3e6bf90d 100644 --- a/util/src/trie/sectriedb.rs +++ b/util/src/trie/sectriedb.rs @@ -34,7 +34,7 @@ impl<'db> SecTrieDB<'db> { /// This guarantees the trie is built correctly. /// Returns an error if root does not exist. pub fn new(db: &'db HashDB, root: &'db H256) -> super::Result { - Ok(SecTrieDB { raw: try!(TrieDB::new(db, root)) }) + Ok(SecTrieDB { raw: TrieDB::new(db, root)? }) } /// Get a reference to the underlying raw `TrieDB` struct. diff --git a/util/src/trie/sectriedbmut.rs b/util/src/trie/sectriedbmut.rs index 6e020b889..ca14b2df6 100644 --- a/util/src/trie/sectriedbmut.rs +++ b/util/src/trie/sectriedbmut.rs @@ -39,7 +39,7 @@ impl<'db> SecTrieDBMut<'db> { /// /// Returns an error if root does not exist. pub fn from_existing(db: &'db mut HashDB, root: &'db mut H256) -> super::Result { - Ok(SecTrieDBMut { raw: try!(TrieDBMut::from_existing(db, root)) }) + Ok(SecTrieDBMut { raw: TrieDBMut::from_existing(db, root)? }) } /// Get the backing database. diff --git a/util/src/trie/triedb.rs b/util/src/trie/triedb.rs index ac1503529..3508908e7 100644 --- a/util/src/trie/triedb.rs +++ b/util/src/trie/triedb.rs @@ -80,7 +80,7 @@ impl<'db> TrieDB<'db> { pub fn keys(&self) -> super::Result> { let mut ret: Vec = Vec::new(); ret.push(self.root.clone()); - try!(self.accumulate_keys(try!(self.root_node(&mut NoOp)), &mut ret)); + self.accumulate_keys(self.root_node(&mut NoOp)?, &mut ret)?; Ok(ret) } @@ -97,7 +97,7 @@ impl<'db> TrieDB<'db> { /// trie. pub fn db_items_remaining(&self) -> super::Result> { let mut ret = self.db.keys(); - for (k, v) in Self::to_map(try!(self.keys())) { + for (k, v) in Self::to_map(self.keys()?) { let keycount = *ret.get(&k).unwrap_or(&0); match keycount <= v as i32 { true => ret.remove(&k), @@ -115,12 +115,12 @@ impl<'db> TrieDB<'db> { acc.push(p.as_val()); } - self.accumulate_keys(try!(self.get_node(payload, &mut NoOp, 0)), acc) + self.accumulate_keys(self.get_node(payload, &mut NoOp, 0)?, acc) }; match node { - Node::Extension(_, ref payload) => try!(handle_payload(payload)), - Node::Branch(ref payloads, _) => for payload in payloads { try!(handle_payload(payload)) }, + Node::Extension(_, ref payload) => handle_payload(payload)?, + Node::Branch(ref payloads, _) => for payload in payloads { handle_payload(payload)? }, _ => {}, } @@ -146,7 +146,7 @@ impl<'db> TrieDB<'db> { /// Indentation helper for `formal_all`. fn fmt_indent(&self, f: &mut fmt::Formatter, size: usize) -> fmt::Result { for _ in 0..size { - try!(write!(f, " ")); + write!(f, " ")?; } Ok(()) } @@ -154,36 +154,36 @@ impl<'db> TrieDB<'db> { /// Recursion helper for implementation of formatting trait. fn fmt_all(&self, node: Node, f: &mut fmt::Formatter, deepness: usize) -> fmt::Result { match node { - Node::Leaf(slice, value) => try!(writeln!(f, "'{:?}: {:?}.", slice, value.pretty())), + Node::Leaf(slice, value) => writeln!(f, "'{:?}: {:?}.", slice, value.pretty())?, Node::Extension(ref slice, ref item) => { - try!(write!(f, "'{:?} ", slice)); + write!(f, "'{:?} ", slice)?; if let Ok(node) = self.get_node(&*item, &mut NoOp, 0) { - try!(self.fmt_all(node, f, deepness)); + self.fmt_all(node, f, deepness)?; } }, Node::Branch(ref nodes, ref value) => { - try!(writeln!(f, "")); + writeln!(f, "")?; if let Some(ref v) = *value { - try!(self.fmt_indent(f, deepness + 1)); - try!(writeln!(f, "=: {:?}", v.pretty())) + self.fmt_indent(f, deepness + 1)?; + writeln!(f, "=: {:?}", v.pretty())? } for i in 0..16 { match self.get_node(&*nodes[i], &mut NoOp, 0) { Ok(Node::Empty) => {}, Ok(n) => { - try!(self.fmt_indent(f, deepness + 1)); - try!(write!(f, "'{:x} ", i)); - try!(self.fmt_all(n, f, deepness + 1)); + self.fmt_indent(f, deepness + 1)?; + write!(f, "'{:x} ", i)?; + self.fmt_all(n, f, deepness + 1)?; } Err(e) => { - try!(write!(f, "ERROR: {}", e)); + write!(f, "ERROR: {}", e)?; } } } }, // empty Node::Empty => { - try!(writeln!(f, "")); + writeln!(f, "")?; } }; Ok(()) @@ -193,7 +193,7 @@ impl<'db> TrieDB<'db> { fn do_lookup<'key, R: 'key>(&'db self, key: &NibbleSlice<'key>, r: &'key mut R) -> super::Result> where 'db: 'key, R: Recorder { - let root_rlp = try!(self.root_data(r)); + let root_rlp = self.root_data(r)?; self.get_from_node(&root_rlp, key, r, 1) } @@ -213,7 +213,7 @@ impl<'db> TrieDB<'db> { Node::Extension(ref slice, ref item) => { let slice = &NibbleSlice::from_encoded(slice).0; if key.starts_with(slice) { - let data = try!(self.get_raw_or_lookup(&*item, r, d)); + let data = self.get_raw_or_lookup(&*item, r, d)?; self.get_from_node(&data, &key.mid(slice.len()), r, d + 1) } else { Ok(None) @@ -222,7 +222,7 @@ impl<'db> TrieDB<'db> { Node::Branch(ref nodes, ref value) => match key.is_empty() { true => Ok(value.clone()), false => { - let node = try!(self.get_raw_or_lookup(&*nodes[key.at(0) as usize], r, d)); + let node = self.get_raw_or_lookup(&*nodes[key.at(0) as usize], r, d)?; self.get_from_node(&node, &key.mid(1), r, d + 1) } }, @@ -291,7 +291,7 @@ impl<'a> TrieDBIterator<'a> { key_nibbles: Vec::new(), }; - try!(db.root_data(&mut NoOp).and_then(|root| r.descend(&root))); + db.root_data(&mut NoOp).and_then(|root| r.descend(&root))?; Ok(r) } @@ -322,10 +322,10 @@ impl<'a> TrieDBIterator<'a> { node: Node::decoded(node), }); self.key_nibbles.extend(slice.iter()); - let data = try!(self.db.get_raw_or_lookup(&*item, &mut r, d)); + let data = self.db.get_raw_or_lookup(&*item, &mut r, d)?; self.seek_descend(&data, &key.mid(slice.len()), d + 1) } else { - try!(self.descend(node)); + self.descend(node)?; Ok(()) } }, @@ -345,7 +345,7 @@ impl<'a> TrieDBIterator<'a> { node: Node::decoded(node), }); self.key_nibbles.push(i); - let child = try!(self.db.get_raw_or_lookup(&*nodes[i as usize], &mut r, d)); + let child = self.db.get_raw_or_lookup(&*nodes[i as usize], &mut r, d)?; self.seek_descend(&child, &key.mid(1), d + 1) } }, @@ -357,7 +357,7 @@ impl<'a> TrieDBIterator<'a> { fn descend(&mut self, d: &[u8]) -> super::Result<()> { self.trail.push(Crumb { status: Status::Entering, - node: try!(self.db.get_node(d, &mut NoOp, 0)), + node: self.db.get_node(d, &mut NoOp, 0)?, }); match self.trail.last().expect("just pushed item; qed").node { Node::Leaf(ref n, _) | Node::Extension(ref n, _) => { self.key_nibbles.extend(NibbleSlice::from_encoded(n).0.iter()); }, @@ -380,7 +380,7 @@ impl<'a> TrieIterator for TrieDBIterator<'a> { self.trail.clear(); self.key_nibbles.clear(); let mut r = NoOp; - let root_rlp = try!(self.db.root_data(&mut r)); + let root_rlp = self.db.root_data(&mut r)?; self.seek_descend(&root_rlp, &NibbleSlice::new(key), 1) } } @@ -456,9 +456,9 @@ impl<'db> Trie for TrieDB<'db> { impl<'db> fmt::Debug for TrieDB<'db> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - try!(writeln!(f, "c={:?} [", self.hash_count)); + writeln!(f, "c={:?} [", self.hash_count)?; let root_rlp = self.db.get(self.root).expect("Trie root not found!"); - try!(self.fmt_all(Node::decoded(&root_rlp), f, 0)); + self.fmt_all(Node::decoded(&root_rlp), f, 0)?; writeln!(f, "]") } } diff --git a/util/src/trie/triedbmut.rs b/util/src/trie/triedbmut.rs index 63720b7b4..b062cd70b 100644 --- a/util/src/trie/triedbmut.rs +++ b/util/src/trie/triedbmut.rs @@ -336,7 +336,7 @@ impl<'a> TrieDBMut<'a> { // cache a node by hash fn cache(&mut self, hash: H256) -> super::Result { - let node_rlp = try!(self.db.get(&hash).ok_or_else(|| Box::new(TrieError::IncompleteDatabase(hash)))); + let node_rlp = self.db.get(&hash).ok_or_else(|| Box::new(TrieError::IncompleteDatabase(hash)))?; let node = Node::from_rlp(&node_rlp, &*self.db, &mut self.storage); Ok(self.storage.alloc(Stored::Cached(node, hash))) } @@ -346,12 +346,12 @@ impl<'a> TrieDBMut<'a> { fn inspect(&mut self, stored: Stored, inspector: F) -> super::Result> where F: FnOnce(&mut Self, Node) -> super::Result { Ok(match stored { - Stored::New(node) => match try!(inspector(self, node)) { + Stored::New(node) => match inspector(self, node)? { Action::Restore(node) => Some((Stored::New(node), false)), Action::Replace(node) => Some((Stored::New(node), true)), Action::Delete => None, }, - Stored::Cached(node, hash) => match try!(inspector(self, node)) { + Stored::Cached(node, hash) => match inspector(self, node)? { Action::Restore(node) => Some((Stored::Cached(node, hash), false)), Action::Replace(node) => { self.death_row.insert(hash); @@ -423,14 +423,14 @@ impl<'a> TrieDBMut<'a> { RlpNode::Extension(ref slice, ref item) => { let slice = &NibbleSlice::from_encoded(slice).0; if key.starts_with(slice) { - self.get_from_db_node(&try!(self.get_raw_or_lookup(&*item)), key.mid(slice.len())) + self.get_from_db_node(&self.get_raw_or_lookup(&*item)?, key.mid(slice.len())) } else { Ok(None) } }, RlpNode::Branch(ref nodes, ref value) => match key.is_empty() { true => Ok(value.clone()), - false => self.get_from_db_node(&try!(self.get_raw_or_lookup(&*nodes[key.at(0) as usize])), key.mid(1)) + false => self.get_from_db_node(&self.get_raw_or_lookup(&*nodes[key.at(0) as usize])?, key.mid(1)) }, _ => Ok(None), } @@ -455,12 +455,12 @@ impl<'a> TrieDBMut<'a> { fn insert_at(&mut self, handle: NodeHandle, partial: NibbleSlice, value: DBValue) -> super::Result<(StorageHandle, bool)> { let h = match handle { NodeHandle::InMemory(h) => h, - NodeHandle::Hash(h) => try!(self.cache(h)), + NodeHandle::Hash(h) => self.cache(h)?, }; let stored = self.storage.destroy(h); - let (new_stored, changed) = try!(self.inspect(stored, move |trie, stored| { + let (new_stored, changed) = self.inspect(stored, move |trie, stored| { trie.insert_inspector(stored, partial, value).map(|a| a.into_action()) - })).expect("Insertion never deletes."); + })?.expect("Insertion never deletes."); Ok((self.storage.alloc(new_stored), changed)) } @@ -490,7 +490,7 @@ impl<'a> TrieDBMut<'a> { let partial = partial.mid(1); if let Some(child) = children[idx].take() { // original had something there. recurse down into it. - let (new_child, changed) = try!(self.insert_at(child, partial, value)); + let (new_child, changed) = self.insert_at(child, partial, value)?; children[idx] = Some(new_child.into()); if !changed { // the new node we composed didn't change. that means our branch is untouched too. @@ -533,7 +533,7 @@ impl<'a> TrieDBMut<'a> { }; // always replace because whatever we get out here is not the branch we started with. - let branch_action = try!(self.insert_inspector(branch, partial, value)).unwrap_node(); + let branch_action = self.insert_inspector(branch, partial, value)?.unwrap_node(); InsertAction::Replace(branch_action) } else if cp == existing_key.len() { trace!(target: "trie", "complete-prefix (cp={:?}): AUGMENT-AT-END", cp); @@ -542,7 +542,7 @@ impl<'a> TrieDBMut<'a> { // make a stub branch and an extension. let branch = Node::Branch(empty_children(), Some(stored_value)); // augment the new branch. - let branch = try!(self.insert_inspector(branch, partial.mid(cp), value)).unwrap_node(); + let branch = self.insert_inspector(branch, partial.mid(cp), value)?.unwrap_node(); // always replace since we took a leaf and made an extension. let branch_handle = self.storage.alloc(Stored::New(branch)).into(); @@ -555,7 +555,7 @@ impl<'a> TrieDBMut<'a> { let low = Node::Leaf(existing_key.mid(cp).encoded(true), stored_value); // augment it. this will result in the Leaf -> cp == 0 routine, // which creates a branch. - let augmented_low = try!(self.insert_inspector(low, partial.mid(cp), value)).unwrap_node(); + let augmented_low = self.insert_inspector(low, partial.mid(cp), value)?.unwrap_node(); // make an extension using it. this is a replacement. InsertAction::Replace(Node::Extension( @@ -586,7 +586,7 @@ impl<'a> TrieDBMut<'a> { }; // continue inserting. - let branch_action = try!(self.insert_inspector(Node::Branch(children, None), partial, value)).unwrap_node(); + let branch_action = self.insert_inspector(Node::Branch(children, None), partial, value)?.unwrap_node(); InsertAction::Replace(branch_action) } else if cp == existing_key.len() { trace!(target: "trie", "complete-prefix (cp={:?}): AUGMENT-AT-END", cp); @@ -594,7 +594,7 @@ impl<'a> TrieDBMut<'a> { // fully-shared prefix. // insert into the child node. - let (new_child, changed) = try!(self.insert_at(child_branch, partial.mid(cp), value)); + let (new_child, changed) = self.insert_at(child_branch, partial.mid(cp), value)?; let new_ext = Node::Extension(existing_key.encoded(false), new_child.into()); // if the child branch wasn't changed, meaning this extension remains the same. @@ -608,7 +608,7 @@ impl<'a> TrieDBMut<'a> { // partially-shared. let low = Node::Extension(existing_key.mid(cp).encoded(false), child_branch); // augment the extension. this will take the cp == 0 path, creating a branch. - let augmented_low = try!(self.insert_inspector(low, partial.mid(cp), value)).unwrap_node(); + let augmented_low = self.insert_inspector(low, partial.mid(cp), value)?.unwrap_node(); // always replace, since this extension is not the one we started with. // this is known because the partial key is only the common prefix. @@ -626,12 +626,12 @@ impl<'a> TrieDBMut<'a> { let stored = match handle { NodeHandle::InMemory(h) => self.storage.destroy(h), NodeHandle::Hash(h) => { - let handle = try!(self.cache(h)); + let handle = self.cache(h)?; self.storage.destroy(handle) } }; - let opt = try!(self.inspect(stored, move |trie, node| trie.remove_inspector(node, partial))); + let opt = self.inspect(stored, move |trie, node| trie.remove_inspector(node, partial))?; Ok(opt.map(|(new, changed)| (self.storage.alloc(new), changed))) } @@ -643,13 +643,13 @@ impl<'a> TrieDBMut<'a> { (Node::Branch(c, None), true) => Action::Restore(Node::Branch(c, None)), (Node::Branch(children, _), true) => { // always replace since we took the value out. - Action::Replace(try!(self.fix(Node::Branch(children, None)))) + Action::Replace(self.fix(Node::Branch(children, None))?) } (Node::Branch(mut children, value), false) => { let idx = partial.at(0) as usize; if let Some(child) = children[idx].take() { trace!(target: "trie", "removing value out of branch child, partial={:?}", partial); - match try!(self.remove_at(child, partial.mid(1))) { + match self.remove_at(child, partial.mid(1))? { Some((new, changed)) => { children[idx] = Some(new.into()); let branch = Node::Branch(children, value); @@ -664,7 +664,7 @@ impl<'a> TrieDBMut<'a> { // the child we took was deleted. // the node may need fixing. trace!(target: "trie", "branch child deleted, partial={:?}", partial); - Action::Replace(try!(self.fix(Node::Branch(children, value)))) + Action::Replace(self.fix(Node::Branch(children, value))?) } } } else { @@ -690,14 +690,14 @@ impl<'a> TrieDBMut<'a> { if cp == existing_len { // try to remove from the child branch. trace!(target: "trie", "removing from extension child, partial={:?}", partial); - match try!(self.remove_at(child_branch, partial.mid(cp))) { + match self.remove_at(child_branch, partial.mid(cp))? { Some((new_child, changed)) => { let new_child = new_child.into(); // if the child branch was unchanged, then the extension is too. // otherwise, this extension may need fixing. match changed { - true => Action::Replace(try!(self.fix(Node::Extension(encoded, new_child)))), + true => Action::Replace(self.fix(Node::Extension(encoded, new_child))?), false => Action::Restore(Node::Extension(encoded, new_child)), } } @@ -768,7 +768,7 @@ impl<'a> TrieDBMut<'a> { let stored = match child { NodeHandle::InMemory(h) => self.storage.destroy(h), NodeHandle::Hash(h) => { - let handle = try!(self.cache(h)); + let handle = self.cache(h)?; self.storage.destroy(handle) } }; @@ -915,7 +915,7 @@ impl<'a> TrieMut for TrieDBMut<'a> { trace!(target: "trie", "insert: key={:?}, value={:?}", key.pretty(), value.pretty()); let root_handle = self.root_handle(); - let (new_handle, changed) = try!(self.insert_at(root_handle, NibbleSlice::new(key), DBValue::from_slice(value))); + let (new_handle, changed) = self.insert_at(root_handle, NibbleSlice::new(key), DBValue::from_slice(value))?; trace!(target: "trie", "insert: altered trie={}", changed); self.root_handle = NodeHandle::InMemory(new_handle); @@ -928,7 +928,7 @@ impl<'a> TrieMut for TrieDBMut<'a> { let root_handle = self.root_handle(); let key = NibbleSlice::new(key); - match try!(self.remove_at(root_handle, key)) { + match self.remove_at(root_handle, key)? { Some((handle, changed)) => { trace!(target: "trie", "remove: altered trie={}", changed); self.root_handle = NodeHandle::InMemory(handle);