Skip to content

Commit ff85381

Browse files
sfacklersfackler
committed
Use protocol's backend enum
1 parent fbcdd6b commit ff85381

File tree

5 files changed

+85
-246
lines changed

5 files changed

+85
-246
lines changed

‎src/lib.rs

Lines changed: 47 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -61,11 +61,11 @@ use std::mem;
6161
use std::result;
6262
use std::sync::Arc;
6363
use std::time::Duration;
64+
use postgres_protocol::message::backend::{self, RowDescriptionEntry};
6465
use postgres_protocol::message::frontend;
6566

6667
use error::{Error, ConnectError, SqlState, DbError};
6768
use io::TlsHandshake;
68-
use message::{Backend, RowDescriptionEntry};
6969
use notification::{Notifications, Notification};
7070
use params::{ConnectParams, IntoConnectParams, UserInfo};
7171
use priv_io::MessageStream;
@@ -79,7 +79,6 @@ mod macros;
7979

8080
mod feature_check;
8181
mod md5;
82-
mod message;
8382
mod priv_io;
8483
mod url;
8584
pub mod error;
@@ -289,29 +288,29 @@ impl InnerConnection {
289288

290289
loop {
291290
match try!(conn.read_message()) {
292-
Backend::BackendKeyData { process_id, secret_key } => {
291+
backend::Message::BackendKeyData { process_id, secret_key } => {
293292
conn.cancel_data.process_id = process_id;
294293
conn.cancel_data.secret_key = secret_key;
295294
}
296-
Backend::ReadyForQuery { .. } => break,
297-
Backend::ErrorResponse { fields } => return DbError::new_connect(fields),
295+
backend::Message::ReadyForQuery { .. } => break,
296+
backend::Message::ErrorResponse { fields } => return DbError::new_connect(fields),
298297
_ => return Err(ConnectError::Io(bad_response())),
299298
}
300299
}
301300

302301
Ok(conn)
303302
}
304303

305-
fn read_message_with_notification(&mut self) -> std_io::Result<Backend> {
304+
fn read_message_with_notification(&mut self) -> std_io::Result<backend::Message> {
306305
debug_assert!(!self.desynchronized);
307306
loop {
308307
match try_desync!(self, self.stream.read_message()) {
309-
Backend::NoticeResponse { fields } => {
308+
backend::Message::NoticeResponse { fields } => {
310309
if let Ok(err) = DbError::new_raw(fields) {
311310
self.notice_handler.handle_notice(err);
312311
}
313312
}
314-
Backend::ParameterStatus { parameter, value } => {
313+
backend::Message::ParameterStatus { parameter, value } => {
315314
self.parameters.insert(parameter, value);
316315
}
317316
val => return Ok(val),
@@ -321,44 +320,44 @@ impl InnerConnection {
321320

322321
fn read_message_with_notification_timeout(&mut self,
323322
timeout: Duration)
324-
-> std::io::Result<Option<Backend>> {
323+
-> std::io::Result<Option<backend::Message>> {
325324
debug_assert!(!self.desynchronized);
326325
loop {
327326
match try_desync!(self, self.stream.read_message_timeout(timeout)) {
328-
Some(Backend::NoticeResponse { fields }) => {
327+
Some(backend::Message::NoticeResponse { fields }) => {
329328
if let Ok(err) = DbError::new_raw(fields) {
330329
self.notice_handler.handle_notice(err);
331330
}
332331
}
333-
Some(Backend::ParameterStatus { parameter, value }) => {
332+
Some(backend::Message::ParameterStatus { parameter, value }) => {
334333
self.parameters.insert(parameter, value);
335334
}
336335
val => return Ok(val),
337336
}
338337
}
339338
}
340339

341-
fn read_message_with_notification_nonblocking(&mut self) -> std::io::Result<Option<Backend>> {
340+
fn read_message_with_notification_nonblocking(&mut self) -> std::io::Result<Option<backend::Message>> {
342341
debug_assert!(!self.desynchronized);
343342
loop {
344343
match try_desync!(self, self.stream.read_message_nonblocking()) {
345-
Some(Backend::NoticeResponse { fields }) => {
344+
Some(backend::Message::NoticeResponse { fields }) => {
346345
if let Ok(err) = DbError::new_raw(fields) {
347346
self.notice_handler.handle_notice(err);
348347
}
349348
}
350-
Some(Backend::ParameterStatus { parameter, value }) => {
349+
Some(backend::Message::ParameterStatus { parameter, value }) => {
351350
self.parameters.insert(parameter, value);
352351
}
353352
val => return Ok(val),
354353
}
355354
}
356355
}
357356

358-
fn read_message(&mut self) -> std_io::Result<Backend> {
357+
fn read_message(&mut self) -> std_io::Result<backend::Message> {
359358
loop {
360359
match try!(self.read_message_with_notification()) {
361-
Backend::NotificationResponse { process_id, channel, payload } => {
360+
backend::Message::NotificationResponse { process_id, channel, payload } => {
362361
self.notifications.push_back(Notification {
363362
process_id: process_id,
364363
channel: channel,
@@ -372,15 +371,15 @@ impl InnerConnection {
372371

373372
fn handle_auth(&mut self, user: UserInfo) -> result::Result<(), ConnectError> {
374373
match try!(self.read_message()) {
375-
Backend::AuthenticationOk => return Ok(()),
376-
Backend::AuthenticationCleartextPassword => {
374+
backend::Message::AuthenticationOk => return Ok(()),
375+
backend::Message::AuthenticationCleartextPassword => {
377376
let pass = try!(user.password.ok_or_else(|| {
378377
ConnectError::ConnectParams("a password was requested but not provided".into())
379378
}));
380379
try!(self.stream.write_message(&frontend::PasswordMessage { password: &pass }));
381380
try!(self.stream.flush());
382381
}
383-
Backend::AuthenticationMD5Password { salt } => {
382+
backend::Message::AuthenticationMD5Password { salt } => {
384383
let pass = try!(user.password.ok_or_else(|| {
385384
ConnectError::ConnectParams("a password was requested but not provided".into())
386385
}));
@@ -395,20 +394,20 @@ impl InnerConnection {
395394
try!(self.stream.write_message(&frontend::PasswordMessage { password: &output }));
396395
try!(self.stream.flush());
397396
}
398-
Backend::AuthenticationKerberosV5 |
399-
Backend::AuthenticationSCMCredential |
400-
Backend::AuthenticationGSS |
401-
Backend::AuthenticationSSPI => {
397+
backend::Message::AuthenticationKerberosV5 |
398+
backend::Message::AuthenticationSCMCredential |
399+
backend::Message::AuthenticationGSS |
400+
backend::Message::AuthenticationSSPI => {
402401
return Err(ConnectError::Io(std_io::Error::new(std_io::ErrorKind::Other,
403402
"unsupported authentication")))
404403
}
405-
Backend::ErrorResponse { fields } => return DbError::new_connect(fields),
404+
backend::Message::ErrorResponse { fields } => return DbError::new_connect(fields),
406405
_ => return Err(ConnectError::Io(bad_response())),
407406
}
408407

409408
match try!(self.read_message()) {
410-
Backend::AuthenticationOk => Ok(()),
411-
Backend::ErrorResponse { fields } => DbError::new_connect(fields),
409+
backend::Message::AuthenticationOk => Ok(()),
410+
backend::Message::ErrorResponse { fields } => DbError::new_connect(fields),
412411
_ => Err(ConnectError::Io(bad_response())),
413412
}
414413
}
@@ -433,22 +432,22 @@ impl InnerConnection {
433432
try!(self.stream.flush());
434433

435434
match try!(self.read_message()) {
436-
Backend::ParseComplete => {}
437-
Backend::ErrorResponse { fields } => {
435+
backend::Message::ParseComplete => {}
436+
backend::Message::ErrorResponse { fields } => {
438437
try!(self.wait_for_ready());
439438
return DbError::new(fields);
440439
}
441440
_ => bad_response!(self),
442441
}
443442

444443
let raw_param_types = match try!(self.read_message()) {
445-
Backend::ParameterDescription { types } => types,
444+
backend::Message::ParameterDescription { types } => types,
446445
_ => bad_response!(self),
447446
};
448447

449448
let raw_columns = match try!(self.read_message()) {
450-
Backend::RowDescription { descriptions } => descriptions,
451-
Backend::NoData => vec![],
449+
backend::Message::RowDescription { descriptions } => descriptions,
450+
backend::Message::NoData => vec![],
452451
_ => bad_response!(self),
453452
};
454453

@@ -471,30 +470,30 @@ impl InnerConnection {
471470
let more_rows;
472471
loop {
473472
match try!(self.read_message()) {
474-
Backend::EmptyQueryResponse |
475-
Backend::CommandComplete { .. } => {
473+
backend::Message::EmptyQueryResponse |
474+
backend::Message::CommandComplete { .. } => {
476475
more_rows = false;
477476
break;
478477
}
479-
Backend::PortalSuspended => {
478+
backend::Message::PortalSuspended => {
480479
more_rows = true;
481480
break;
482481
}
483-
Backend::DataRow { row } => buf.push_back(row),
484-
Backend::ErrorResponse { fields } => {
482+
backend::Message::DataRow { row } => buf.push_back(row),
483+
backend::Message::ErrorResponse { fields } => {
485484
try!(self.wait_for_ready());
486485
return DbError::new(fields);
487486
}
488-
Backend::CopyInResponse { .. } => {
487+
backend::Message::CopyInResponse { .. } => {
489488
try!(self.stream.write_message(&frontend::CopyFail {
490489
message: "COPY queries cannot be directly executed",
491490
}));
492491
try!(self.stream.write_message(&frontend::Sync));
493492
try!(self.stream.flush());
494493
}
495-
Backend::CopyOutResponse { .. } => {
494+
backend::Message::CopyOutResponse { .. } => {
496495
loop {
497-
if let Backend::ReadyForQuery { .. } = try!(self.read_message()) {
496+
if let backend::Message::ReadyForQuery { .. } = try!(self.read_message()) {
498497
break;
499498
}
500499
}
@@ -550,8 +549,8 @@ impl InnerConnection {
550549
try!(self.stream.flush());
551550

552551
match try!(self.read_message()) {
553-
Backend::BindComplete => Ok(()),
554-
Backend::ErrorResponse { fields } => {
552+
backend::Message::BindComplete => Ok(()),
553+
backend::Message::ErrorResponse { fields } => {
555554
try!(self.wait_for_ready());
556555
DbError::new(fields)
557556
}
@@ -608,8 +607,8 @@ impl InnerConnection {
608607
try!(self.stream.write_message(&frontend::Sync));
609608
try!(self.stream.flush());
610609
let resp = match try!(self.read_message()) {
611-
Backend::CloseComplete => Ok(()),
612-
Backend::ErrorResponse { fields } => DbError::new(fields),
610+
backend::Message::CloseComplete => Ok(()),
611+
backend::Message::ErrorResponse { fields } => DbError::new(fields),
613612
_ => bad_response!(self),
614613
};
615614
try!(self.wait_for_ready());
@@ -797,7 +796,7 @@ impl InnerConnection {
797796
#[allow(needless_return)]
798797
fn wait_for_ready(&mut self) -> Result<()> {
799798
match try!(self.read_message()) {
800-
Backend::ReadyForQuery { .. } => Ok(()),
799+
backend::Message::ReadyForQuery { .. } => Ok(()),
801800
_ => bad_response!(self),
802801
}
803802
}
@@ -811,20 +810,20 @@ impl InnerConnection {
811810
let mut result = vec![];
812811
loop {
813812
match try!(self.read_message()) {
814-
Backend::ReadyForQuery { .. } => break,
815-
Backend::DataRow { row } => {
813+
backend::Message::ReadyForQuery { .. } => break,
814+
backend::Message::DataRow { row } => {
816815
result.push(row.into_iter()
817816
.map(|opt| opt.map(|b| String::from_utf8_lossy(&b).into_owned()))
818817
.collect());
819818
}
820-
Backend::CopyInResponse { .. } => {
819+
backend::Message::CopyInResponse { .. } => {
821820
try!(self.stream.write_message(&frontend::CopyFail {
822821
message: "COPY queries cannot be directly executed",
823822
}));
824823
try!(self.stream.write_message(&frontend::Sync));
825824
try!(self.stream.flush());
826825
}
827-
Backend::ErrorResponse { fields } => {
826+
backend::Message::ErrorResponse { fields } => {
828827
try!(self.wait_for_ready());
829828
return DbError::new(fields);
830829
}

0 commit comments

Comments
 (0)