Add connection to serialization

mason-mariadb/src/connection/mod.rs

@@ -5,7 +5,7 @@ use crate::protocol::{
     deserialize::Deserialize,
     encode::Encoder,
     packets::{com_ping::ComPing, com_quit::ComQuit, ok::OkPacket},
-    serialize::{Serialize, Serializer},
+    serialize::Serialize,
     server::Message as ServerMessage,
     types::{Capabilities, ServerStatusFlag},
 };
@@ -100,7 +100,7 @@ impl Connection {
         self.encoder.clear();
         self.encoder.alloc_packet_header();
         self.encoder.seq_no(self.seq_no);
-        Serializer::new(self).serialize(message)?;
+        message.serialize(self)?;
         self.encoder.encode_length();
 
         self.stream.inner.write_all(&self.encoder.buf).await?;

mason-mariadb/src/protocol/packets/auth_switch_request.rs

@@ -1,4 +1,5 @@
-use super::super::{encode::Encoder, serialize::Serialize, types::Capabilities};
+use super::super::serialize::Serialize;
+use crate::connection::Connection;
 use bytes::Bytes;
 use failure::Error;
 
@@ -9,14 +10,10 @@ pub struct AuthenticationSwitchRequestPacket {
 }
 
 impl Serialize for AuthenticationSwitchRequestPacket {
-    fn serialize(
+    fn serialize(&self, conn: &mut Connection) -> Result<(), Error> {
-        &self,
+        conn.encoder.encode_int_1(0xFE);
-        encoder: &mut Encoder,
+        conn.encoder.encode_string_null(&self.auth_plugin_name);
-        _server_capabilities: &Capabilities,
+        conn.encoder.encode_byte_eof(&self.auth_plugin_data);
-    ) -> Result<(), Error> {
-        encoder.encode_int_1(0xFE);
-        encoder.encode_string_null(&self.auth_plugin_name);
-        encoder.encode_byte_eof(&self.auth_plugin_data);
 
         Ok(())
     }

mason-mariadb/src/protocol/packets/com_debug.rs

@@ -1,17 +1,12 @@
-use super::super::{
+use super::super::{client::TextProtocol, serialize::Serialize};
-    client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
+use crate::connection::Connection;
-};
 use failure::Error;
 
 pub struct ComDebug();
 
 impl Serialize for ComDebug {
-    fn serialize<'a, 'b>(
+    fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
-        &self,
+        conn.encoder.encode_int_1(TextProtocol::ComDebug.into());
-        encoder: &mut Encoder,
-        _server_capabilities: &Capabilities,
-    ) -> Result<(), Error> {
-        encoder.encode_int_1(TextProtocol::ComDebug.into());
 
         Ok(())
     }

mason-mariadb/src/protocol/packets/com_init_db.rs

@@ -1,6 +1,5 @@
-use super::super::{
+use super::super::{client::TextProtocol, serialize::Serialize};
-    client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
+use crate::connection::Connection;
-};
 use bytes::Bytes;
 use failure::Error;
 
@@ -9,13 +8,9 @@ pub struct ComInitDb {
 }
 
 impl Serialize for ComInitDb {
-    fn serialize<'a, 'b>(
+    fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
-        &self,
+        conn.encoder.encode_int_1(TextProtocol::ComInitDb.into());
-        encoder: &mut Encoder,
+        conn.encoder.encode_string_null(&self.schema_name);
-        _server_capabilities: &Capabilities,
-    ) -> Result<(), Error> {
-        encoder.encode_int_1(TextProtocol::ComInitDb.into());
-        encoder.encode_string_null(&self.schema_name);
 
         Ok(())
     }

mason-mariadb/src/protocol/packets/com_ping.rs

@@ -1,17 +1,12 @@
-use super::super::{
+use super::super::{client::TextProtocol, serialize::Serialize};
-    client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
+use crate::connection::Connection;
-};
 use failure::Error;
 
 pub struct ComPing();
 
 impl Serialize for ComPing {
-    fn serialize<'a, 'b>(
+    fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
-        &self,
+        conn.encoder.encode_int_1(TextProtocol::ComPing.into());
-        encoder: &mut Encoder,
-        _server_capabilities: &Capabilities,
-    ) -> Result<(), Error> {
-        encoder.encode_int_1(TextProtocol::ComPing.into());
 
         Ok(())
     }

mason-mariadb/src/protocol/packets/com_process_kill.rs

@@ -1,6 +1,5 @@
-use super::super::{
+use super::super::{client::TextProtocol, serialize::Serialize};
-    client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
+use crate::connection::Connection;
-};
 use failure::Error;
 
 pub struct ComProcessKill {
@@ -8,13 +7,9 @@ pub struct ComProcessKill {
 }
 
 impl Serialize for ComProcessKill {
-    fn serialize<'a, 'b>(
+    fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
-        &self,
+        conn.encoder.encode_int_1(TextProtocol::ComProcessKill.into());
-        encoder: &mut Encoder,
+        conn.encoder.encode_int_4(self.process_id);
-        _server_capabilities: &Capabilities,
-    ) -> Result<(), Error> {
-        encoder.encode_int_1(TextProtocol::ComProcessKill.into());
-        encoder.encode_int_4(self.process_id);
 
         Ok(())
     }

mason-mariadb/src/protocol/packets/com_query.rs

@@ -1,6 +1,5 @@
-use super::super::{
+use super::super::{client::TextProtocol, serialize::Serialize};
-    client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
+use crate::connection::Connection;
-};
 use bytes::Bytes;
 use failure::Error;
 
@@ -9,13 +8,9 @@ pub struct ComQuery {
 }
 
 impl Serialize for ComQuery {
-    fn serialize<'a, 'b>(
+    fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
-        &self,
+        conn.encoder.encode_int_1(TextProtocol::ComQuery.into());
-        encoder: &mut Encoder,
+        conn.encoder.encode_string_eof(&self.sql_statement);
-        _server_capabilities: &Capabilities,
-    ) -> Result<(), Error> {
-        encoder.encode_int_1(TextProtocol::ComQuery.into());
-        encoder.encode_string_eof(&self.sql_statement);
 
         Ok(())
     }

mason-mariadb/src/protocol/packets/com_quit.rs

@@ -1,17 +1,12 @@
-use super::super::{
+use super::super::{client::TextProtocol, serialize::Serialize};
-    client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
+use crate::connection::Connection;
-};
 use failure::Error;
 
 pub struct ComQuit();
 
 impl Serialize for ComQuit {
-    fn serialize<'a, 'b>(
+    fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
-        &self,
+        conn.encoder.encode_int_1(TextProtocol::ComQuit.into());
-        encoder: &mut Encoder,
-        _server_capabilities: &Capabilities,
-    ) -> Result<(), Error> {
-        encoder.encode_int_1(TextProtocol::ComQuit.into());
 
         Ok(())
     }

mason-mariadb/src/protocol/packets/com_reset_conn.rs

@@ -1,17 +1,12 @@
-use super::super::{
+use super::super::{client::TextProtocol, serialize::Serialize};
-    client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
+use crate::connection::Connection;
-};
 use failure::Error;
 
 pub struct ComResetConnection();
 
 impl Serialize for ComResetConnection {
-    fn serialize<'a, 'b>(
+    fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
-        &self,
+        conn.encoder.encode_int_1(TextProtocol::ComResetConnection.into());
-        encoder: &mut Encoder,
-        _server_capabilities: &Capabilities,
-    ) -> Result<(), Error> {
-        encoder.encode_int_1(TextProtocol::ComResetConnection.into());
 
         Ok(())
     }

mason-mariadb/src/protocol/packets/com_set_option.rs

@@ -1,6 +1,5 @@
-use super::super::{
+use super::super::{client::TextProtocol, serialize::Serialize};
-    client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
+use crate::connection::Connection;
-};
 use failure::Error;
 
 #[derive(Clone, Copy)]
@@ -14,13 +13,9 @@ pub struct ComSetOption {
 }
 
 impl Serialize for ComSetOption {
-    fn serialize<'a, 'b>(
+    fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
-        &self,
+        conn.encoder.encode_int_1(TextProtocol::ComSetOption.into());
-        encoder: &mut Encoder,
+        conn.encoder.encode_int_2(self.option.into());
-        _server_capabilities: &Capabilities,
-    ) -> Result<(), Error> {
-        encoder.encode_int_1(TextProtocol::ComSetOption.into());
-        encoder.encode_int_2(self.option.into());
 
         Ok(())
     }

mason-mariadb/src/protocol/packets/com_shutdown.rs

@@ -1,4 +1,5 @@
-use super::super::{client::TextProtocol, encode::*, serialize::Serialize, types::Capabilities};
+use super::super::{client::TextProtocol, serialize::Serialize};
+use crate::connection::Connection;
 use failure::Error;
 
 #[derive(Clone, Copy)]
@@ -11,13 +12,9 @@ pub struct ComShutdown {
 }
 
 impl Serialize for ComShutdown {
-    fn serialize<'a, 'b>(
+    fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
-        &self,
+        conn.encoder.encode_int_1(TextProtocol::ComShutdown.into());
-        encoder: &mut Encoder,
+        conn.encoder.encode_int_1(self.option.into());
-        _server_capabilities: &Capabilities,
-    ) -> Result<(), Error> {
-        encoder.encode_int_1(TextProtocol::ComShutdown.into());
-        encoder.encode_int_1(self.option.into());
 
         Ok(())
     }

mason-mariadb/src/protocol/packets/com_sleep.rs

@@ -1,17 +1,12 @@
-use super::super::{
+use super::super::{client::TextProtocol, serialize::Serialize};
-    client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
+use crate::connection::Connection;
-};
 use failure::Error;
 
 pub struct ComSleep();
 
 impl Serialize for ComSleep {
-    fn serialize<'a, 'b>(
+    fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
-        &self,
+        conn.encoder.encode_int_1(TextProtocol::ComSleep.into());
-        encoder: &mut Encoder,
-        _server_capabilities: &Capabilities,
-    ) -> Result<(), Error> {
-        encoder.encode_int_1(TextProtocol::ComSleep.into());
 
         Ok(())
     }

mason-mariadb/src/protocol/packets/com_statistics.rs

@@ -1,17 +1,12 @@
-use super::super::{
+use super::super::{client::TextProtocol, serialize::Serialize};
-    client::TextProtocol, encode::Encoder, serialize::Serialize, types::Capabilities,
+use crate::connection::Connection;
-};
 use failure::Error;
 
 pub struct ComStatistics();
 
 impl Serialize for ComStatistics {
-    fn serialize<'a, 'b>(
+    fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
-        &self,
+        conn.encoder.encode_int_1(TextProtocol::ComStatistics.into());
-        encoder: &mut Encoder,
-        _server_capabilities: &Capabilities,
-    ) -> Result<(), Error> {
-        encoder.encode_int_1(TextProtocol::ComStatistics.into());
 
         Ok(())
     }

mason-mariadb/src/protocol/packets/handshake_response.rs

@@ -1,4 +1,5 @@
-use super::super::{encode::Encoder, serialize::Serialize, types::Capabilities};
+use super::super::{serialize::Serialize, types::Capabilities};
+use crate::connection::Connection;
 use bytes::Bytes;
 use failure::Error;
 
@@ -19,66 +20,63 @@ pub struct HandshakeResponsePacket {
 }
 
 impl Serialize for HandshakeResponsePacket {
-    fn serialize<'a, 'b>(
+    fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
-        &self,
+        conn.encoder.encode_int_4(self.capabilities.bits() as u32);
-        encoder: &mut Encoder,
+        conn.encoder.encode_int_4(self.max_packet_size);
-        server_capabilities: &Capabilities,
+        conn.encoder.encode_int_1(self.collation);
-    ) -> Result<(), Error> {
-        encoder.encode_int_4(self.capabilities.bits() as u32);
-        encoder.encode_int_4(self.max_packet_size);
-        encoder.encode_int_1(self.collation);
 
         // Filler
-        encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 19]), 19);
+        conn.encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 19]), 19);
 
-        if !(*server_capabilities & Capabilities::CLIENT_MYSQL).is_empty()
+        if !(conn.capabilities & Capabilities::CLIENT_MYSQL).is_empty()
             && !(self.capabilities & Capabilities::CLIENT_MYSQL).is_empty()
         {
             if let Some(capabilities) = self.extended_capabilities {
-                encoder.encode_int_4(capabilities.bits() as u32);
+                conn.encoder.encode_int_4(capabilities.bits() as u32);
             }
         } else {
-            encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 4]), 4);
+            conn.encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 4]), 4);
         }
 
-        encoder.encode_string_null(&self.username);
+        conn.encoder.encode_string_null(&self.username);
 
-        if !(*server_capabilities & Capabilities::PLUGIN_AUTH_LENENC_CLIENT_DATA).is_empty() {
+        if !(conn.capabilities & Capabilities::PLUGIN_AUTH_LENENC_CLIENT_DATA).is_empty() {
             if let Some(auth_data) = &self.auth_data {
-                encoder.encode_string_lenenc(&auth_data);
+                conn.encoder.encode_string_lenenc(&auth_data);
             }
-        } else if !(*server_capabilities & Capabilities::SECURE_CONNECTION).is_empty() {
+        } else if !(conn.capabilities & Capabilities::SECURE_CONNECTION).is_empty() {
             if let Some(auth_response) = &self.auth_response {
-                encoder.encode_int_1(self.auth_response_len.unwrap());
+                conn.encoder.encode_int_1(self.auth_response_len.unwrap());
-                encoder.encode_string_fix(&auth_response, self.auth_response_len.unwrap() as usize);
+                conn.encoder
+                    .encode_string_fix(&auth_response, self.auth_response_len.unwrap() as usize);
             }
         } else {
-            encoder.encode_int_1(0);
+            conn.encoder.encode_int_1(0);
         }
 
-        if !(*server_capabilities & Capabilities::CONNECT_WITH_DB).is_empty() {
+        if !(conn.capabilities & Capabilities::CONNECT_WITH_DB).is_empty() {
             if let Some(database) = &self.database {
                 // string<NUL>
-                encoder.encode_string_null(&database);
+                conn.encoder.encode_string_null(&database);
             }
         }
 
-        if !(*server_capabilities & Capabilities::PLUGIN_AUTH).is_empty() {
+        if !(conn.capabilities & Capabilities::PLUGIN_AUTH).is_empty() {
             if let Some(auth_plugin_name) = &self.auth_plugin_name {
                 // string<NUL>
-                encoder.encode_string_null(&auth_plugin_name);
+                conn.encoder.encode_string_null(&auth_plugin_name);
             }
         }
 
-        if !(*server_capabilities & Capabilities::CONNECT_ATTRS).is_empty() {
+        if !(conn.capabilities & Capabilities::CONNECT_ATTRS).is_empty() {
             if let (Some(conn_attr_len), Some(conn_attr)) = (&self.conn_attr_len, &self.conn_attr) {
                 // int<lenenc>
-                encoder.encode_int_lenenc(Some(conn_attr_len));
+                conn.encoder.encode_int_lenenc(Some(conn_attr_len));
 
                 // Loop
                 for (key, value) in conn_attr {
-                    encoder.encode_string_lenenc(&key);
+                    conn.encoder.encode_string_lenenc(&key);
-                    encoder.encode_string_lenenc(&value);
+                    conn.encoder.encode_string_lenenc(&value);
                 }
             }
         }

mason-mariadb/src/protocol/packets/ssl_request.rs

@@ -1,4 +1,5 @@
-use super::super::{encode::Encoder, serialize::Serialize, types::Capabilities};
+use super::super::{serialize::Serialize, types::Capabilities};
+use crate::connection::Connection;
 use bytes::Bytes;
 use failure::Error;
 
@@ -11,26 +12,22 @@ pub struct SSLRequestPacket {
 }
 
 impl Serialize for SSLRequestPacket {
-    fn serialize<'a, 'b>(
+    fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error> {
-        &self,
+        conn.encoder.encode_int_4(self.capabilities.bits() as u32);
-        encoder: &mut Encoder,
+        conn.encoder.encode_int_4(self.max_packet_size);
-        server_capabilities: &Capabilities,
+        conn.encoder.encode_int_1(self.collation);
-    ) -> Result<(), Error> {
-        encoder.encode_int_4(self.capabilities.bits() as u32);
-        encoder.encode_int_4(self.max_packet_size);
-        encoder.encode_int_1(self.collation);
 
         // Filler
-        encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 19]), 19);
+        conn.encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 19]), 19);
 
-        if !(*server_capabilities & Capabilities::CLIENT_MYSQL).is_empty()
+        if !(conn.capabilities & Capabilities::CLIENT_MYSQL).is_empty()
             && !(self.capabilities & Capabilities::CLIENT_MYSQL).is_empty()
         {
             if let Some(capabilities) = self.extended_capabilities {
-                encoder.encode_int_4(capabilities.bits() as u32);
+                conn.encoder.encode_int_4(capabilities.bits() as u32);
             }
         } else {
-            encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 4]), 4);
+            conn.encoder.encode_byte_fix(&Bytes::from_static(&[0u8; 4]), 4);
         }
 
         Ok(())

mason-mariadb/src/protocol/serialize.rs

@@ -1,28 +1,6 @@
-use super::{super::connection::Connection, encode::Encoder, types::Capabilities};
+use super::super::connection::Connection;
 use failure::Error;
 
 pub trait Serialize {
-    fn serialize<'a, 'b>(
+    fn serialize<'a, 'b>(&self, conn: &mut Connection) -> Result<(), Error>;
-        &self,
-        encoder: &'b mut Encoder,
-        server_capabilities: &Capabilities,
-    ) -> Result<(), Error>;
-}
-
-pub struct Serializer<'a> {
-    pub conn: &'a mut Connection,
-}
-
-impl<'a> Serializer<'a> {
-    #[inline]
-    pub fn new(conn: &'a mut Connection) -> Self {
-        Serializer {
-            conn,
-        }
-    }
-
-    #[inline]
-    pub fn serialize<S: Serialize>(&mut self, message: S) -> Result<(), Error> {
-        message.serialize(&mut self.conn.encoder, &self.conn.capabilities)
-    }
 }