Skip to content

Commit c16d144

Browse files
sfacklersfackler
committed
Stop glob importing messages
1 parent da8707a commit c16d144

File tree

4 files changed

+141
-144
lines changed

4 files changed

+141
-144
lines changed

‎src/lib.rs

Lines changed: 59 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -75,8 +75,6 @@ pub use transaction::Transaction;
7575

7676
use error::{Error, ConnectError, SqlState, DbError};
7777
use io::{StreamWrapper, NegotiateSsl};
78-
use message::Backend::*;
79-
use message::Frontend::*;
8078
use message::{Frontend, Backend, RowDescriptionEntry};
8179
use message::{WriteMessage, ReadMessage};
8280
use notification::{Notifications, Notification};
@@ -285,7 +283,7 @@ pub fn cancel_query<T>(params: T,
285283
let params = try!(params.into_connect_params().map_err(ConnectError::ConnectParams));
286284
let mut socket = try!(priv_io::initialize_stream(&params, ssl));
287285

288-
try!(socket.write_message(&CancelRequest {
286+
try!(socket.write_message(&Frontend::CancelRequest {
289287
code: message::CANCEL_CODE,
290288
process_id: data.process_id,
291289
secret_key: data.secret_key,
@@ -436,7 +434,7 @@ impl InnerConnection {
436434
options.push(("database".to_owned(), database));
437435
}
438436

439-
try!(conn.write_messages(&[StartupMessage {
437+
try!(conn.write_messages(&[Frontend::StartupMessage {
440438
version: message::PROTOCOL_VERSION,
441439
parameters: &options,
442440
}]));
@@ -445,12 +443,12 @@ impl InnerConnection {
445443

446444
loop {
447445
match try!(conn.read_message()) {
448-
BackendKeyData { process_id, secret_key } => {
446+
Backend::BackendKeyData { process_id, secret_key } => {
449447
conn.cancel_data.process_id = process_id;
450448
conn.cancel_data.secret_key = secret_key;
451449
}
452-
ReadyForQuery { .. } => break,
453-
ErrorResponse { fields } => return DbError::new_connect(fields),
450+
Backend::ReadyForQuery { .. } => break,
451+
Backend::ErrorResponse { fields } => return DbError::new_connect(fields),
454452
_ => return Err(ConnectError::Io(bad_response())),
455453
}
456454
}
@@ -533,12 +531,12 @@ impl InnerConnection {
533531
debug_assert!(!self.desynchronized);
534532
loop {
535533
match try_desync!(self, self.stream.read_message()) {
536-
NoticeResponse { fields } => {
534+
Backend::NoticeResponse { fields } => {
537535
if let Ok(err) = DbError::new_raw(fields) {
538536
self.notice_handler.handle_notice(err);
539537
}
540538
}
541-
ParameterStatus { parameter, value } => {
539+
Backend::ParameterStatus { parameter, value } => {
542540
self.parameters.insert(parameter, value);
543541
}
544542
val => return Ok(val),
@@ -552,12 +550,12 @@ impl InnerConnection {
552550
debug_assert!(!self.desynchronized);
553551
loop {
554552
match try_desync!(self, self.stream.read_message_timeout(timeout)) {
555-
Some(NoticeResponse { fields }) => {
553+
Some(Backend::NoticeResponse { fields }) => {
556554
if let Ok(err) = DbError::new_raw(fields) {
557555
self.notice_handler.handle_notice(err);
558556
}
559557
}
560-
Some(ParameterStatus { parameter, value }) => {
558+
Some(Backend::ParameterStatus { parameter, value }) => {
561559
self.parameters.insert(parameter, value);
562560
}
563561
val => return Ok(val),
@@ -570,12 +568,12 @@ impl InnerConnection {
570568
debug_assert!(!self.desynchronized);
571569
loop {
572570
match try_desync!(self, self.stream.read_message_nonblocking()) {
573-
Some(NoticeResponse { fields }) => {
571+
Some(Backend::NoticeResponse { fields }) => {
574572
if let Ok(err) = DbError::new_raw(fields) {
575573
self.notice_handler.handle_notice(err);
576574
}
577575
}
578-
Some(ParameterStatus { parameter, value }) => {
576+
Some(Backend::ParameterStatus { parameter, value }) => {
579577
self.parameters.insert(parameter, value);
580578
}
581579
val => return Ok(val),
@@ -586,7 +584,7 @@ impl InnerConnection {
586584
fn read_message(&mut self) -> std_io::Result<Backend> {
587585
loop {
588586
match try!(self.read_message_with_notification()) {
589-
NotificationResponse { pid, channel, payload } => {
587+
Backend::NotificationResponse { pid, channel, payload } => {
590588
self.notifications.push_back(Notification {
591589
pid: pid,
592590
channel: channel,
@@ -600,14 +598,14 @@ impl InnerConnection {
600598

601599
fn handle_auth(&mut self, user: UserInfo) -> result::Result<(), ConnectError> {
602600
match try!(self.read_message()) {
603-
AuthenticationOk => return Ok(()),
604-
AuthenticationCleartextPassword => {
601+
Backend::AuthenticationOk => return Ok(()),
602+
Backend::AuthenticationCleartextPassword => {
605603
let pass = try!(user.password.ok_or_else(|| {
606604
ConnectError::ConnectParams("a password was requested but not provided".into())
607605
}));
608-
try!(self.write_messages(&[PasswordMessage { password: &pass }]));
606+
try!(self.write_messages(&[Frontend::PasswordMessage { password: &pass }]));
609607
}
610-
AuthenticationMD5Password { salt } => {
608+
Backend::AuthenticationMD5Password { salt } => {
611609
let pass = try!(user.password.ok_or_else(|| {
612610
ConnectError::ConnectParams("a password was requested but not provided".into())
613611
}));
@@ -619,22 +617,22 @@ impl InnerConnection {
619617
hasher.input(output.as_bytes());
620618
hasher.input(&salt);
621619
let output = format!("md5{}", hasher.result_str());
622-
try!(self.write_messages(&[PasswordMessage { password: &output }]));
620+
try!(self.write_messages(&[Frontend::PasswordMessage { password: &output }]));
623621
}
624-
AuthenticationKerberosV5 |
625-
AuthenticationSCMCredential |
626-
AuthenticationGSS |
627-
AuthenticationSSPI => {
622+
Backend::AuthenticationKerberosV5 |
623+
Backend::AuthenticationSCMCredential |
624+
Backend::AuthenticationGSS |
625+
Backend::AuthenticationSSPI => {
628626
return Err(ConnectError::Io(std_io::Error::new(std_io::ErrorKind::Other,
629627
"unsupported authentication")))
630628
}
631-
ErrorResponse { fields } => return DbError::new_connect(fields),
629+
Backend::ErrorResponse { fields } => return DbError::new_connect(fields),
632630
_ => return Err(ConnectError::Io(bad_response())),
633631
}
634632

635633
match try!(self.read_message()) {
636-
AuthenticationOk => Ok(()),
637-
ErrorResponse { fields } => DbError::new_connect(fields),
634+
Backend::AuthenticationOk => Ok(()),
635+
Backend::ErrorResponse { fields } => DbError::new_connect(fields),
638636
_ => Err(ConnectError::Io(bad_response())),
639637
}
640638
}
@@ -646,34 +644,34 @@ impl InnerConnection {
646644
fn raw_prepare(&mut self, stmt_name: &str, query: &str) -> Result<(Vec<Type>, Vec<Column>)> {
647645
debug!("preparing query with name `{}`: {}", stmt_name, query);
648646

649-
try!(self.write_messages(&[Parse {
647+
try!(self.write_messages(&[Frontend::Parse {
650648
name: stmt_name,
651649
query: query,
652650
param_types: &[],
653651
},
654-
Describe {
652+
Frontend::Describe {
655653
variant: b'S',
656654
name: stmt_name,
657655
},
658-
Sync]));
656+
Frontend::Sync]));
659657

660658
match try!(self.read_message()) {
661-
ParseComplete => {}
662-
ErrorResponse { fields } => {
659+
Backend::ParseComplete => {}
660+
Backend::ErrorResponse { fields } => {
663661
try!(self.wait_for_ready());
664662
return DbError::new(fields);
665663
}
666664
_ => bad_response!(self),
667665
}
668666

669667
let raw_param_types = match try!(self.read_message()) {
670-
ParameterDescription { types } => types,
668+
Backend::ParameterDescription { types } => types,
671669
_ => bad_response!(self),
672670
};
673671

674672
let raw_columns = match try!(self.read_message()) {
675-
RowDescription { descriptions } => descriptions,
676-
NoData => vec![],
673+
Backend::RowDescription { descriptions } => descriptions,
674+
Backend::NoData => vec![],
677675
_ => bad_response!(self),
678676
};
679677

@@ -696,29 +694,29 @@ impl InnerConnection {
696694
let more_rows;
697695
loop {
698696
match try!(self.read_message()) {
699-
EmptyQueryResponse | CommandComplete { .. } => {
697+
Backend::EmptyQueryResponse | Backend::CommandComplete { .. } => {
700698
more_rows = false;
701699
break;
702700
}
703-
PortalSuspended => {
701+
Backend::PortalSuspended => {
704702
more_rows = true;
705703
break;
706704
}
707-
DataRow { row } => buf.push_back(row),
708-
ErrorResponse { fields } => {
705+
Backend::DataRow { row } => buf.push_back(row),
706+
Backend::ErrorResponse { fields } => {
709707
try!(self.wait_for_ready());
710708
return DbError::new(fields);
711709
}
712-
CopyInResponse { .. } => {
713-
try!(self.write_messages(&[CopyFail {
710+
Backend::CopyInResponse { .. } => {
711+
try!(self.write_messages(&[Frontend::CopyFail {
714712
message: "COPY queries cannot be directly \
715713
executed",
716714
},
717-
Sync]));
715+
Frontend::Sync]));
718716
}
719-
CopyOutResponse { .. } => {
717+
Backend::CopyOutResponse { .. } => {
720718
loop {
721-
if let ReadyForQuery { .. } = try!(self.read_message()) {
719+
if let Backend::ReadyForQuery { .. } = try!(self.read_message()) {
722720
break;
723721
}
724722
}
@@ -759,22 +757,22 @@ impl InnerConnection {
759757
}
760758
}
761759

762-
try!(self.write_messages(&[Bind {
760+
try!(self.write_messages(&[Frontend::Bind {
763761
portal: portal_name,
764762
statement: &stmt_name,
765763
formats: &[1],
766764
values: &values,
767765
result_formats: &[1],
768766
},
769-
Execute {
767+
Frontend::Execute {
770768
portal: portal_name,
771769
max_rows: row_limit,
772770
},
773-
Sync]));
771+
Frontend::Sync]));
774772

775773
match try!(self.read_message()) {
776-
BindComplete => Ok(()),
777-
ErrorResponse { fields } => {
774+
Backend::BindComplete => Ok(()),
775+
Backend::ErrorResponse { fields } => {
778776
try!(self.wait_for_ready());
779777
DbError::new(fields)
780778
}
@@ -824,14 +822,14 @@ impl InnerConnection {
824822
}
825823

826824
fn close_statement(&mut self, name: &str, type_: u8) -> Result<()> {
827-
try!(self.write_messages(&[Close {
825+
try!(self.write_messages(&[Frontend::Close {
828826
variant: type_,
829827
name: name,
830828
},
831-
Sync]));
829+
Frontend::Sync]));
832830
let resp = match try!(self.read_message()) {
833-
CloseComplete => Ok(()),
834-
ErrorResponse { fields } => DbError::new(fields),
831+
Backend::CloseComplete => Ok(()),
832+
Backend::ErrorResponse { fields } => DbError::new(fields),
835833
_ => bad_response!(self),
836834
};
837835
try!(self.wait_for_ready());
@@ -940,35 +938,35 @@ impl InnerConnection {
940938
#[allow(needless_return)]
941939
fn wait_for_ready(&mut self) -> Result<()> {
942940
match try!(self.read_message()) {
943-
ReadyForQuery { .. } => Ok(()),
941+
Backend::ReadyForQuery { .. } => Ok(()),
944942
_ => bad_response!(self),
945943
}
946944
}
947945

948946
fn quick_query(&mut self, query: &str) -> Result<Vec<Vec<Option<String>>>> {
949947
check_desync!(self);
950948
debug!("executing query: {}", query);
951-
try!(self.write_messages(&[Query { query: query }]));
949+
try!(self.write_messages(&[Frontend::Query { query: query }]));
952950

953951
let mut result = vec![];
954952
loop {
955953
match try!(self.read_message()) {
956-
ReadyForQuery { .. } => break,
957-
DataRow { row } => {
954+
Backend::ReadyForQuery { .. } => break,
955+
Backend::DataRow { row } => {
958956
result.push(row.into_iter()
959957
.map(|opt| {
960958
opt.map(|b| String::from_utf8_lossy(&b).into_owned())
961959
})
962960
.collect());
963961
}
964-
CopyInResponse { .. } => {
965-
try!(self.write_messages(&[CopyFail {
962+
Backend::CopyInResponse { .. } => {
963+
try!(self.write_messages(&[Frontend::CopyFail {
966964
message: "COPY queries cannot be directly \
967965
executed",
968966
},
969-
Sync]));
967+
Frontend::Sync]));
970968
}
971-
ErrorResponse { fields } => {
969+
Backend::ErrorResponse { fields } => {
972970
try!(self.wait_for_ready());
973971
return DbError::new(fields);
974972
}
@@ -980,7 +978,7 @@ impl InnerConnection {
980978

981979
fn finish_inner(&mut self) -> Result<()> {
982980
check_desync!(self);
983-
try!(self.write_messages(&[Terminate]));
981+
try!(self.write_messages(&[Frontend::Terminate]));
984982
Ok(())
985983
}
986984
}

0 commit comments

Comments
 (0)