Add ToRemoteAddrs trait and implementations

2 files changed, 78 insertions, 7 deletions

diff --git a/src/net.rs b/src/net.rs
index 250720782e..ad601c0a40 100644
--- a/src/net.rs
+++ b/src/net.rs
@@ -2,8 +2,13 @@ use regex::Regex;
 
 use std::error::Error;
 use std::fmt;
+use std::io;
+use std::iter;
 use std::net::SocketAddr;
+use std::option;
+use std::slice;
 use std::str::FromStr;
+use std::vec;
 
 /// Representation of a TCP or UDP endpoint. The host is represented as a String since it can be
 /// both a hostname/domain as well as an IP.
@@ -84,6 +89,61 @@ impl Error for AddrParseError {
 }
 
 
+/// A trait for objects which can be converted to one or more `RemoteAddr` values.
+pub trait ToRemoteAddrs {
+    /// Returned iterator over remote addresses which this type may correspond
+    /// to.
+    type Iter: Iterator<Item = RemoteAddr>;
+
+    /// Converts this object to an iterator of parsed `RemoteAddr`s.
+    ///
+    /// # Errors
+    ///
+    /// Any errors encountered during parsing will be returned as an `Err`.
+    fn to_remote_addrs(&self) -> io::Result<Self::Iter>;
+}
+
+impl ToRemoteAddrs for RemoteAddr {
+    type Iter = option::IntoIter<RemoteAddr>;
+    fn to_remote_addrs(&self) -> io::Result<Self::Iter> {
+        Ok(Some(self.clone()).into_iter())
+    }
+}
+
+impl<'a> ToRemoteAddrs for &'a [RemoteAddr] {
+    type Iter = iter::Cloned<slice::Iter<'a, RemoteAddr>>;
+
+    fn to_remote_addrs(&self) -> io::Result<Self::Iter> {
+        Ok(self.iter().cloned())
+    }
+}
+
+impl<'a> ToRemoteAddrs for &'a str {
+    type Iter = option::IntoIter<RemoteAddr>;
+    fn to_remote_addrs(&self) -> io::Result<Self::Iter> {
+        let addr = str_to_remote_addr(self)?;
+        Ok(Some(addr).into_iter())
+    }
+}
+
+impl<'a> ToRemoteAddrs for &'a [&'a str] {
+    type Iter = vec::IntoIter<RemoteAddr>;
+
+    fn to_remote_addrs(&self) -> io::Result<Self::Iter> {
+        let mut addrs = vec![];
+        for addr in self.iter() {
+            let parsed_addr = str_to_remote_addr(addr)?;
+            addrs.push(parsed_addr);
+        }
+        Ok(addrs.into_iter())
+    }
+}
+
+fn str_to_remote_addr(s: &str) -> io::Result<RemoteAddr> {
+    RemoteAddr::from_str(s)
+        .map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, e.description()))
+}
+
 #[cfg(test)]
 mod tests {
     use std::net::SocketAddr;
diff --git a/src/process.rs b/src/process.rs
index 17257c46d2..fce338ade7 100644
--- a/src/process.rs
+++ b/src/process.rs
@@ -1,4 +1,4 @@
-use net::RemoteAddr;
+use net::{RemoteAddr, ToRemoteAddrs};
 
 use std::ffi::{OsString, OsStr};
 use std::fmt;
@@ -33,9 +33,9 @@ impl OpenVpnBuilder {
 
     /// Sets the addresses that OpenVPN will connect to. See OpenVPN documentation for how multiple
     /// remotes are handled.
-    pub fn remotes(&mut self, remotes: Vec<RemoteAddr>) -> &mut Self {
-        self.remotes = remotes;
-        self
+    pub fn remotes<A: ToRemoteAddrs>(&mut self, remotes: A) -> io::Result<&mut Self> {
+        self.remotes = remotes.to_remote_addrs()?.collect();
+        Ok(self)
     }
 
     /// Executes the OpenVPN process as a child process, returning a handle to it.
@@ -109,9 +109,9 @@ mod tests {
 
     #[test]
     fn passes_one_remote() {
-        let remotes = vec![RemoteAddr::new("example.com", 3333)];
+        let remotes = RemoteAddr::new("example.com", 3333);
 
-        let args = OpenVpnBuilder::new("").remotes(remotes).get_arguments();
+        let args = OpenVpnBuilder::new("").remotes(remotes).unwrap().get_arguments();
 
         assert!(args.contains(&OsString::from("example.com")));
         assert!(args.contains(&OsString::from("3333")));
@@ -121,11 +121,22 @@ mod tests {
     fn passes_two_remotes() {
         let remotes = vec![RemoteAddr::new("127.0.0.1", 998), RemoteAddr::new("fe80::1", 1337)];
 
-        let args = OpenVpnBuilder::new("").remotes(remotes).get_arguments();
+        let args = OpenVpnBuilder::new("").remotes(&remotes[..]).unwrap().get_arguments();
 
         assert!(args.contains(&OsString::from("127.0.0.1")));
         assert!(args.contains(&OsString::from("998")));
         assert!(args.contains(&OsString::from("fe80::1")));
         assert!(args.contains(&OsString::from("1337")));
     }
+
+    #[test]
+    fn accepts_str() {
+        assert!(OpenVpnBuilder::new("").remotes("10.0.0.1:1377").is_ok());
+    }
+
+    #[test]
+    fn accepts_slice_of_str() {
+        let remotes = ["10.0.0.1:1377", "127.0.0.1:99"];
+        assert!(OpenVpnBuilder::new("").remotes(&remotes[..]).is_ok());
+    }
 }