Included address and auth token to provider client

src/clients/mod.rs

@@ -133,8 +133,8 @@ impl NymClient {
         }
     }
 
-    async fn start_provider_polling(provider_address: SocketAddrV4) {
-        let provider_client = ProviderClient::new(provider_address);
+    async fn start_provider_polling(provider_client: ProviderClient) {
+//        let provider_client = ProviderClient::new(provider_address);
 
         loop {
             println!("[FETCH MSG] - Polling provider...");
@@ -150,6 +150,18 @@ impl NymClient {
     pub fn start(self) -> Result<(), Box<dyn std::error::Error>> {
         println!("starting nym client");
 
+        let topology = get_topology(self.is_local);
+        let provider_address: SocketAddrV4 = topology
+            .mix_provider_nodes
+            .first()
+            .unwrap()
+            .host
+            .parse()
+            .unwrap();
+
+
+
+        let provider_client = ProviderClient::new(provider_address, self.address, self.auth_token);
 
         match self.auth_token {
             None => println!("Need to register!"),
@@ -162,14 +174,6 @@ impl NymClient {
 
         let (mix_tx, mix_rx) = mpsc::unbounded();
         let mut rt = Runtime::new()?;
-        let topology = get_topology(self.is_local);
-        let provider_address: SocketAddrV4 = topology
-            .mix_provider_nodes
-            .first()
-            .unwrap()
-            .host
-            .parse()
-            .unwrap();
 
         let mix_traffic_future = rt.spawn(MixTrafficController::run(mix_rx));
         let loop_cover_traffic_future = rt.spawn(NymClient::start_loop_cover_traffic_stream(
@@ -185,7 +189,7 @@ impl NymClient {
             topology.clone(),
         ));
 
-        let provider_polling_future = rt.spawn(NymClient::start_provider_polling(provider_address));
+        let provider_polling_future = rt.spawn(NymClient::start_provider_polling(provider_client));
         let websocket_future = rt.spawn(ws::start_websocket(self.socket_listening_address, self.input_tx));
 
         rt.block_on(async {

src/clients/provider.rs

@@ -1,33 +1,56 @@
-use sfw_provider_requests::requests::{ProviderRequest, PullRequest};
+use sfw_provider_requests::requests::{ProviderRequest, PullRequest, AuthToken, RegisterRequest};
 use sfw_provider_requests::responses::{ProviderResponse, PullResponse};
 use std::net::{Shutdown, SocketAddr};
 use std::net::SocketAddrV4;
 use tokio::prelude::*;
 use std::time::Duration;
+use sphinx::route::DestinationAddressBytes;
+use futures::io::Error;
+
+#[derive(Debug)]
+pub enum ProviderClientError {
+    EmptyAuthTokenError,
+    NetworkError,
+}
+
+impl From<io::Error> for ProviderClientError {
+    fn from(_: Error) -> Self {
+        use ProviderClientError::*;
+
+        NetworkError
+    }
+}
+
 
 pub struct ProviderClient {
-    address: SocketAddrV4,
+    provider_network_address: SocketAddrV4,
+    our_address: DestinationAddressBytes,
+    auth_token: Option<AuthToken>,
 }
 
 impl ProviderClient {
-    pub fn new(address: SocketAddrV4) -> Self {
+    pub fn new(provider_network_address: SocketAddrV4, our_address: DestinationAddressBytes, auth_token: Option<AuthToken>) -> Self {
         ProviderClient {
-            address
+            provider_network_address,
+            our_address,
+            auth_token,
         }
     }
 
     pub async fn retrieve_messages(
         &self,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        let destination_address = [42u8; 32];
-        let dummy_auth_token_to_make_it_compile = [0u8; 32];
-        let pull_request = PullRequest::new(destination_address, dummy_auth_token_to_make_it_compile);
+    ) -> Result<(), ProviderClientError> {
+        if self.auth_token.is_none() {
+            return Err(ProviderClientError::EmptyAuthTokenError)
+        }
+
+        let pull_request = PullRequest::new(self.our_address, self.auth_token.unwrap());
         let bytes = pull_request.to_bytes();
 
         // DH temporary: the provider's client port is not in the topology, but we can't change that
         // right now without messing up the existing Go mixnet. So I'm going to hardcode this
         // for the moment until the Go mixnet goes away.
-        let provider_socket = SocketAddrV4::new(*self.address.ip(), 9000);
+        let provider_socket = SocketAddrV4::new(*self.provider_network_address.ip(), 9000);
         println!("Provider: {:?}", provider_socket);
 
         let mut socket = tokio::net::TcpStream::connect(provider_socket).await?;
@@ -51,4 +74,10 @@ impl ProviderClient {
         }
         Ok(())
     }
+
+    pub async fn register(&mut self) -> Result<AuthToken, Box<dyn std::error::Error>> {
+        let register_request = RegisterRequest::new(self.our_address);
+
+        Ok([0;32])
+    }
 }