rust
/
rust-fastcgi
mirror of https://github.com/mohtar/rust-fastcgi
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Swap deprecated `try!(x)` for `x.?`

This commit is contained in:
Robert D French 2020-01-23 21:22:24 -05:00
parent 1dd769db40
commit 101954840d
2 changed files with 53 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
src/lib.rs
View File

@ -90,10 +90,10 @@ enum Record {
fn read_len<R: Read>(mut r: &mut R) -> io::Result<u32> {
let mut buf: Vec<u8> = Vec::with_capacity(4);
try!((&mut r).take(1).read_to_end(&mut buf));
(&mut r).take(1).read_to_end(&mut buf)?;
if buf.len() == 1 {
if buf[0] >> 7 == 1 {
assert!(try!((&mut r).take(3).read_to_end(&mut buf)) == 3);
assert!((&mut r).take(3).read_to_end(&mut buf)? == 3);
Ok(
(((buf[0] & 0x7f) as u32) << 24)
+ ((buf[1] as u32) << 16)
@ -109,12 +109,12 @@ fn read_len<R: Read>(mut r: &mut R) -> io::Result<u32> {
}
fn read_pair<R: Read>(mut r: &mut R) -> io::Result<(String, String)> {
let key_len = try!(read_len(r));
let value_len = try!(read_len(r));
let key_len = read_len(r)?;
let value_len = read_len(r)?;
let mut key = String::with_capacity(key_len as usize);
assert!(try!((&mut r).take(key_len as u64).read_to_string(&mut key)) == key_len as usize);
assert!((&mut r).take(key_len as u64).read_to_string(&mut key)? == key_len as usize);
let mut value = String::with_capacity(value_len as usize);
assert!(try!((&mut r).take(value_len as u64).read_to_string(&mut value)) == value_len as usize);
assert!((&mut r).take(value_len as u64).read_to_string(&mut value)? == value_len as usize);
Ok((key, value))
}
@ -123,7 +123,7 @@ fn read_pairs<R: Read>(r: &mut R) -> io::Result<Vec<(String, String)>> {
match read_pair(r) {
Ok(param) => {
params.push(param);
params.extend(try!(read_pairs(r)).into_iter());
params.extend(read_pairs(r)?.into_iter());
Ok(params)
},
Err(_) => Ok(params),
@ -132,22 +132,22 @@ fn read_pairs<R: Read>(r: &mut R) -> io::Result<Vec<(String, String)>> {
fn write_len<W: Write>(w: &mut W, n: u32) -> io::Result<()> {
if n < 0x80 {
try!(w.write_all(&[n as u8]));
w.write_all(&[n as u8])?;
} else {
assert!(n < 0x80000000);
let buf = unsafe {
mem::transmute::<u32, [u8; 4]>((0x80000000 & n).to_be())
};
try!(w.write_all(&buf));
w.write_all(&buf)?;
}
Ok(())
}
fn write_pairs<W: Write>(w: &mut W, pairs: Vec<(String, String)>) -> io::Result<()> {
for (key, value) in pairs {
try!(write_len(w, key.len() as u32));
try!(write_len(w, value.len() as u32));
try!(write!(w, "{}{}", key, value));
write_len(w, key.len() as u32)?;
write_len(w, value.len() as u32)?;
write!(w, "{}{}", key, value)?;
}
Ok(())
}
@ -161,26 +161,26 @@ fn write_record<W: Write>(w: &mut W, record_type: u8, request_id: u16, content:
let content_length = unsafe {
mem::transmute::<_, [u8; 2]>((content.len() as u16).to_be())
};
try!(w.write_all(&[
w.write_all(&[
1, record_type, request_id[0], request_id[1],
content_length[0], content_length[1], 0, 0,
])); // TODO: Padding
try!(w.write_all(content));
])?; // TODO: Padding
w.write_all(content)?;
Ok(())
}
#[inline]
fn read_record<R: Read>(r: &mut R) -> io::Result<(u8, u16, Vec<u8>)> {
let mut header: Vec<u8> = Vec::with_capacity(HEADER_LEN);
assert!(try!(r.take(HEADER_LEN as u64).read_to_end(&mut header)) == HEADER_LEN);
assert!(r.take(HEADER_LEN as u64).read_to_end(&mut header)? == HEADER_LEN);
assert!(header[0] == 1);
let record_type = header[1];
let request_id = unsafe { u16::from_be(mem::transmute([header[2], header[3]])) };
let content_length = unsafe { u16::from_be(mem::transmute([header[4], header[5]])) };
let padding_length = header[6];
let mut content: Vec<u8> = Vec::with_capacity(content_length as usize);
assert!(try!(r.take(content_length as u64).read_to_end(&mut content)) == content_length as usize);
assert!(try!(r.take(padding_length as u64).read_to_end(&mut Vec::with_capacity(padding_length as usize))) == padding_length as usize);
assert!(r.take(content_length as u64).read_to_end(&mut content)? == content_length as usize);
assert!(r.take(padding_length as u64).read_to_end(&mut Vec::with_capacity(padding_length as usize))? == padding_length as usize);
Ok((record_type, request_id, content))
}
@ -201,22 +201,22 @@ impl Record {
app_status[0], app_status[1], app_status[2], app_status[3],
protocol_status, 0, 0, 0,
];
try!(write_record(w, 3, request_id, &content));
write_record(w, 3, request_id, &content)?;
},
Record::Stdout { request_id, content } => {
try!(write_record(w, 6, request_id, &content));
write_record(w, 6, request_id, &content)?;
},
Record::Stderr { request_id, content } => {
try!(write_record(w, 7, request_id, &content));
write_record(w, 7, request_id, &content)?;
},
Record::GetValuesResult(items) => {
let mut content = Cursor::new(Vec::new());
try!(write_pairs(&mut content, items));
try!(write_record(w, 10, 0, &content.into_inner()));
write_pairs(&mut content, items)?;
write_record(w, 10, 0, &content.into_inner())?;
},
Record::UnknownType(record_type) => {
let content = [record_type, 0, 0, 0, 0, 0, 0, 0];
try!(write_record(w, 11, 0, &content));
write_record(w, 11, 0, &content)?;
},
_ => panic!("Record not sendable"),
}
@ -224,7 +224,7 @@ impl Record {
}
fn receive<R: Read>(r: &mut R) -> io::Result<Self> {
let (record_type, request_id, content) = try!(read_record(r));
let (record_type, request_id, content) = read_record(r)?;
let rec = match record_type {
1 => {
let role = unsafe {
@ -248,7 +248,7 @@ impl Record {
5 => Record::Stdin { request_id: request_id, content: content },
8 => Record::Data { request_id: request_id, content: content },
9 => {
let items = try!(read_pairs(&mut Cursor::new(content)));
let items = read_pairs(&mut Cursor::new(content))?;
Record::GetValues(items.into_iter().map(|(key, _)| key).collect())
},
_ if record_type >= 11 => Record::UnknownType(record_type),
@ -285,24 +285,21 @@ impl<'a> BufRead for Stdin<'a> {
if self.req.pos == self.req.buf.len() && !self.req.is_eof {
let mut sock = &*self.req.sock;
loop {
match (try!(Record::receive(&mut sock)), self.req.filter_data) {
match (Record::receive(&mut sock)?, self.req.filter_data) {
(Record::UnknownType(rec_type), _) => {
try!(Record::UnknownType(rec_type).send(&mut sock));
Record::UnknownType(rec_type).send(&mut sock)?;
},
(Record::GetValues(keys), _) => {
try!(
Record::GetValuesResult(get_values(keys))
.send(&mut sock)
);
Record::GetValuesResult(get_values(keys))
.send(&mut sock)?
},
(Record::BeginRequest { request_id, .. }, _) => {
try!(Record::EndRequest {
request_id: request_id,
app_status: 0,
protocol_status: ProtocolStatus::CantMpxConn,
}
.send(&mut sock)
);
Record::EndRequest {
request_id: request_id,
app_status: 0,
protocol_status: ProtocolStatus::CantMpxConn,
}
.send(&mut sock)?
},
(Record::AbortRequest { request_id }, _) => {
if request_id != self.req.id {
@ -338,8 +335,8 @@ impl<'a> BufRead for Stdin<'a> {
impl<'a> Read for Stdin<'a> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
let n = {
let mut chunk = try!(self.fill_buf());
try!(chunk.read(buf))
let mut chunk = self.fill_buf()?;
chunk.read(buf)?
};
self.consume(n);
Ok(n)
@ -365,7 +362,7 @@ macro_rules! writer {
request_id: self.req.id,
content: chunk.to_owned(),
};
try!(rec.send(&mut &*self.req.sock));
rec.send(&mut &*self.req.sock)?;
}
Ok(buf.len())
}
@ -401,7 +398,7 @@ pub struct Request {
filter_data: bool,
}
pub type Params<'a> = Box<Iterator<Item = (String, String)> + 'a>;
pub type Params<'a> = Box<dyn Iterator<Item = (String, String)> + 'a>;
fn get_values(keys: Vec<String>) -> Vec<(String, String)> {
keys.into_iter().filter_map(|key|
@ -417,22 +414,22 @@ fn get_values(keys: Vec<String>) -> Vec<(String, String)> {
impl Request {
fn begin(mut sock: &Socket) -> io::Result<(u16, Role, bool)> {
loop {
match try!(Record::receive(&mut sock)) {
match Record::receive(&mut sock)? {
Record::UnknownType(rec_type) => {
try!(Record::UnknownType(rec_type).send(&mut sock));
Record::UnknownType(rec_type).send(&mut sock)?;
},
Record::GetValues(keys) => {
try!(Record::GetValuesResult(get_values(keys)).send(&mut sock));
Record::GetValuesResult(get_values(keys)).send(&mut sock)?;
},
Record::BeginRequest { request_id, role: Ok(role), keep_conn } => {
return Ok((request_id, role, keep_conn));
},
Record::BeginRequest { request_id, role: Err(_), .. } => {
try!(Record::EndRequest {
Record::EndRequest {
request_id: request_id,
app_status: 0,
protocol_status: ProtocolStatus::UnknownRole
}.send(&mut sock));
}.send(&mut sock)?;
},
_ => (),
}
@ -444,24 +441,21 @@ impl Request {
let mut params = HashMap::new();
let mut aborted = false;
loop {
match try!(Record::receive(&mut &*sock)) {
match Record::receive(&mut &*sock)? {
Record::UnknownType(rec_type) => {
try!(Record::UnknownType(rec_type).send(&mut &*sock));
Record::UnknownType(rec_type).send(&mut &*sock)?;
},
Record::GetValues(keys) => {
try!(
Record::GetValuesResult(get_values(keys))
.send(&mut &*sock)
);
.send(&mut &*sock)?
},
Record::BeginRequest { request_id, .. } => {
try!(Record::EndRequest {
Record::EndRequest {
request_id: request_id,
app_status: 0,
protocol_status: ProtocolStatus::CantMpxConn,
}
.send(&mut &*sock)
);
.send(&mut &*sock)?
}
Record::AbortRequest { request_id } => {
if id != request_id {
@ -475,7 +469,7 @@ impl Request {
continue;
}
if content.is_empty() {
params.extend(try!(read_pairs(&mut Cursor::new(&buf))));
params.extend(read_pairs(&mut Cursor::new(&buf))?);
break;
} else {
buf.extend(content);

4
src/windows.rs
View File

@ -36,7 +36,7 @@ impl<'a> Transport<'a> {
}
pub fn accept(&mut self) -> io::Result<Socket> {
let (stream, _) = try!(self.inner.accept());
let (stream, _) = self.inner.accept()?;
Ok(Socket { inner: stream })
}
}
@ -47,7 +47,7 @@ pub struct Socket {
impl Socket {
pub fn peer(&self) -> io::Result<String> {
match try!(self.inner.peer_addr()) {
match self.inner.peer_addr()? {
SocketAddr::V4(addr) => Ok(addr.ip().to_string()),
SocketAddr::V6(addr) => Ok(addr.ip().to_string()),
}