fs: add fs::copy (#2079)

Provides an asynchronous version of `std::fs::copy`.

Closes: #2076

4 files changed, 45 insertions, 1 deletions

diff --git a/tokio/Cargo.toml b/tokio/Cargo.toml
index 9cf41355..ea1fec0c 100644
--- a/tokio/Cargo.toml
+++ b/tokio/Cargo.toml
@@ -49,7 +49,7 @@ full = [
 
 blocking = ["rt-core"]
 dns = ["rt-core"]
-fs = ["rt-core"]
+fs = ["rt-core", "io-util"]
 io-driver = ["mio", "lazy_static"]
 io-util = ["memchr"]
 # stdin, stdout, stderr
diff --git a/tokio/src/fs/copy.rs b/tokio/src/fs/copy.rs
new file mode 100644
index 00000000..e39924c5
--- /dev/null
+++ b/tokio/src/fs/copy.rs
@@ -0,0 +1,26 @@
+use crate::fs::File;
+use crate::io;
+use std::path::Path;
+
+/// Copies the contents of one file to another. This function will also copy the permission bits of the original file to the destination file.
+/// This function will overwrite the contents of to.
+///
+/// This is the async equivalent of `std::fs::copy`.
+///
+/// # Examples
+///
+/// ```no_run
+/// use tokio::fs;
+///
+/// # async fn dox() -> std::io::Result<()> {
+/// fs::copy("foo.txt", "bar.txt").await?;
+/// # Ok(())
+/// # }
+/// ```
+
+pub async fn copy<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> Result<u64, std::io::Error> {
+    let from = File::open(from).await?;
+    let to = File::create(to).await?;
+    let (mut from, mut to) = (io::BufReader::new(from), io::BufWriter::new(to));
+    io::copy(&mut from, &mut to).await
+}
diff --git a/tokio/src/fs/mod.rs b/tokio/src/fs/mod.rs
index 266364b9..3eb03764 100644
--- a/tokio/src/fs/mod.rs
+++ b/tokio/src/fs/mod.rs
@@ -80,6 +80,9 @@ pub use self::symlink_metadata::symlink_metadata;
 mod write;
 pub use self::write::write;
 
+mod copy;
+pub use self::copy::copy;
+
 use std::io;
 
 pub(crate) async fn asyncify<F, T>(f: F) -> io::Result<T>
diff --git a/tokio/tests/fs_copy.rs b/tokio/tests/fs_copy.rs
new file mode 100644
index 00000000..e8c1b7a3
--- /dev/null
+++ b/tokio/tests/fs_copy.rs
@@ -0,0 +1,15 @@
+#![warn(rust_2018_idioms)]
+#![cfg(feature = "full")]
+
+use tokio::fs;
+
+#[tokio::test]
+async fn copy() {
+    fs::write("foo.txt", b"Hello File!").await.unwrap();
+    fs::copy("foo.txt", "bar.txt").await.unwrap();
+
+    let from = fs::read("foo.txt").await.unwrap();
+    let to = fs::read("bar.txt").await.unwrap();
+
+    assert_eq!(from, to);
+}