Skip to content

Commit

Permalink
Merge pull request #23 from laerling/separate-modules
Browse files Browse the repository at this point in the history 
Move modules to own files
  • Loading branch information
@baoyachi
baoyachi authored Apr 6, 2024
2 parents 4184f8e + de7b778 commit f0046c2
Show file tree
Hide file tree
Showing 4 changed files with 240 additions and 245 deletions.
76 changes: 76 additions & 0 deletions src/async_digest.rs
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,76 @@
use crate::{CalculatorSelector, TrySha256Digest};
use bytes::BytesMut;
use std::io;

/// sha256 digest file
///
/// # Examples
///
/// ```rust
/// use sha256::{try_async_digest};
/// use std::path::Path;
/// let input = Path::new("./foo.file");
/// tokio_test::block_on(async{
/// let val = try_async_digest(input).await.unwrap();
/// assert_eq!(val,"433855b7d2b96c23a6f60e70c655eb4305e8806b682a9596a200642f947259b1")
/// });
///
/// ```
pub async fn try_async_digest<D: TrySha256Digest>(input: D) -> Result<String, D::Error> {
input.async_digest().await
}

/// sha256 digest file
///
/// # Examples
///
/// ```rust
/// use sha256::{try_async_openssl_digest};
/// use std::path::Path;
/// let input = Path::new("./foo.file");
/// tokio_test::block_on(async{
/// let val = try_async_openssl_digest(input).await.unwrap();
/// assert_eq!(val,"433855b7d2b96c23a6f60e70c655eb4305e8806b682a9596a200642f947259b1")
/// });
/// ```
#[cfg(feature = "native_openssl")]
pub async fn try_async_openssl_digest<D: TrySha256Digest>(
input: D,
) -> Result<String, D::Error> {
input.async_openssl_digest().await
}

#[async_trait::async_trait]
pub trait AsyncCalculatorInput {
async fn read_inner(&mut self, buf: &mut BytesMut) -> io::Result<usize>;
}

pub async fn async_calc<I, S>(mut input: I, mut selector: S) -> io::Result<String>
where
I: AsyncCalculatorInput,
S: CalculatorSelector,
{
let mut buf = BytesMut::with_capacity(1024);
loop {
buf.clear();
let len = input.read_inner(&mut buf).await?;
if len == 0 {
break;
}
selector.update_inner(&buf[0..len]);
}
let hash = selector.finish_inner();
Ok(hex::encode(hash))
}

#[async_trait::async_trait]
impl<R> AsyncCalculatorInput for tokio::io::BufReader<R>
where
R: tokio::io::AsyncRead + Unpin + Send,
{
async fn read_inner(&mut self, buf: &mut BytesMut) -> io::Result<usize> {
use tokio::io::AsyncReadExt;

self.read_buf(buf).await
}
}
252 changes: 7 additions & 245 deletions src/lib.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -50,6 +50,13 @@ use std::io;
use std::io::{BufReader, Read};
use std::path::Path;

#[cfg(feature = "async")]
pub mod async_digest;
#[cfg(test)]
mod tests;
#[cfg(feature = "native_openssl")]
mod openssl_sha256;

/// sha256 digest string
///
/// # Examples
Expand Down Expand Up @@ -266,248 +273,3 @@ where
let hash = selector.finish_inner();
Ok(hex::encode(hash))
}

#[cfg(feature = "async")]
pub mod async_digest {
use crate::{CalculatorSelector, TrySha256Digest};
use bytes::BytesMut;
use std::io;

/// sha256 digest file
///
/// # Examples
///
/// ```rust
/// use sha256::{try_async_digest};
/// use std::path::Path;
/// let input = Path::new("./foo.file");
/// tokio_test::block_on(async{
/// let val = try_async_digest(input).await.unwrap();
/// assert_eq!(val,"433855b7d2b96c23a6f60e70c655eb4305e8806b682a9596a200642f947259b1")
/// });
///
/// ```
pub async fn try_async_digest<D: TrySha256Digest>(input: D) -> Result<String, D::Error> {
input.async_digest().await
}

/// sha256 digest file
///
/// # Examples
///
/// ```rust
/// use sha256::{try_async_openssl_digest};
/// use std::path::Path;
/// let input = Path::new("./foo.file");
/// tokio_test::block_on(async{
/// let val = try_async_openssl_digest(input).await.unwrap();
/// assert_eq!(val,"433855b7d2b96c23a6f60e70c655eb4305e8806b682a9596a200642f947259b1")
/// });
/// ```
#[cfg(feature = "native_openssl")]
pub async fn try_async_openssl_digest<D: TrySha256Digest>(
input: D,
) -> Result<String, D::Error> {
input.async_openssl_digest().await
}

#[async_trait::async_trait]
pub trait AsyncCalculatorInput {
async fn read_inner(&mut self, buf: &mut BytesMut) -> io::Result<usize>;
}

pub async fn async_calc<I, S>(mut input: I, mut selector: S) -> io::Result<String>
where
I: AsyncCalculatorInput,
S: CalculatorSelector,
{
let mut buf = BytesMut::with_capacity(1024);
loop {
buf.clear();
let len = input.read_inner(&mut buf).await?;
if len == 0 {
break;
}
selector.update_inner(&buf[0..len]);
}
let hash = selector.finish_inner();
Ok(hex::encode(hash))
}

#[async_trait::async_trait]
impl<R> AsyncCalculatorInput for tokio::io::BufReader<R>
where
R: tokio::io::AsyncRead + Unpin + Send,
{
async fn read_inner(&mut self, buf: &mut BytesMut) -> io::Result<usize> {
use tokio::io::AsyncReadExt;

self.read_buf(buf).await
}
}
}

#[cfg(feature = "native_openssl")]
mod openssl_sha256 {
use crate::CalculatorSelector;

pub type OpenSslSha256 = openssl::sha::Sha256;

impl CalculatorSelector for OpenSslSha256 {
type FinishType = [u8; 32];

fn update_inner(&mut self, data: &[u8]) {
self.update(data)
}

fn finish_inner(self) -> Self::FinishType {
self.finish()
}
}
}

#[cfg(test)]
mod tests {
use super::*;

#[cfg(feature = "native_openssl")]
#[test]
fn test_openssl() {
let input = Path::new("./foo.file");
let f = fs::File::open(input).unwrap();
let reader = BufReader::new(f);
let sha = openssl::sha::Sha256::new();
assert_eq!(
"433855b7d2b96c23a6f60e70c655eb4305e8806b682a9596a200642f947259b1",
calc(reader, sha).unwrap()
);
}

#[test]
fn test_sha256() {
let input = Path::new("./foo.file");
let f = fs::File::open(input).unwrap();
let reader = BufReader::new(f);
let sha = Sha256::new();
assert_eq!(
"433855b7d2b96c23a6f60e70c655eb4305e8806b682a9596a200642f947259b1",
calc(reader, sha).unwrap()
);
}

#[cfg(all(feature = "async", feature = "native_openssl"))]
#[tokio::test]
async fn test_async_openssl() {
let input = Path::new("./foo.file");
let f = tokio::fs::File::open(input).await.unwrap();
let reader = tokio::io::BufReader::new(f);
let sha = openssl::sha::Sha256::new();
assert_eq!(
"433855b7d2b96c23a6f60e70c655eb4305e8806b682a9596a200642f947259b1",
async_calc(reader, sha).await.unwrap()
);
}

#[cfg(feature = "async")]
#[tokio::test]
async fn test_async() {
let input = Path::new("./foo.file");
let f = tokio::fs::File::open(input).await.unwrap();
let reader = tokio::io::BufReader::new(f);
let sha = Sha256::new();
assert_eq!(
"433855b7d2b96c23a6f60e70c655eb4305e8806b682a9596a200642f947259b1",
async_calc(reader, sha).await.unwrap()
);
}

#[cfg(all(feature = "async", feature = "native_openssl"))]
#[tokio::test]
async fn test_try_async_openssl_digest() {
let hash = try_async_openssl_digest("./foo.file").await.unwrap();
assert_eq!(
"433855b7d2b96c23a6f60e70c655eb4305e8806b682a9596a200642f947259b1",
hash
);
}

#[cfg(feature = "async")]
#[tokio::test]
async fn test_try_async_digest() {
let hash = try_async_digest("./foo.file").await.unwrap();
assert_eq!(
"433855b7d2b96c23a6f60e70c655eb4305e8806b682a9596a200642f947259b1",
hash
);
}

#[cfg(feature = "async")]
#[tokio::test]
async fn test_async_parity() {
let bytes = (0..0x1000).map(|v| (v % 256) as u8).collect::<Vec<_>>();
let val = digest(&bytes);

let async_res = {
let bytes = &bytes;
// We want to force Poll::Pending on reads during async_calc, which may break parity
// between sync and async hashing.
let (client, mut server) = tokio::io::duplex(64);
let reader = tokio::io::BufReader::new(client);
let sha = Sha256::new();

use tokio::io::AsyncWriteExt;
tokio::join! {
async_calc(reader, sha),
async move {
server.write_all(&bytes[..]).await.unwrap();
core::mem::drop(server);
}
}
.0
.unwrap()
};

let sync_res = {
let reader = BufReader::new(&*bytes);
let sha = Sha256::new();
calc(reader, sha).unwrap()
};
assert_eq!(val, async_res);
assert_eq!(async_res, sync_res);
}

#[cfg(all(feature = "async", feature = "native_openssl"))]
#[tokio::test]
async fn test_async_parity_openssl() {
let bytes = (0..0x1000).map(|v| (v % 256) as u8).collect::<Vec<_>>();
let val = digest(&bytes);

let async_res = {
let bytes = &bytes;
// We want to force Poll::Pending on reads during async_calc, which may break parity
// between sync and async hashing.
let (client, mut server) = tokio::io::duplex(64);
let reader = tokio::io::BufReader::new(client);
let sha = OpenSslSha256::new();

use tokio::io::AsyncWriteExt;
tokio::join! {
async_calc(reader, sha),
async move {
server.write_all(&bytes[..]).await.unwrap();
core::mem::drop(server);
}
}
.0
.unwrap()
};

let sync_res = {
let reader = BufReader::new(&*bytes);
let sha = OpenSslSha256::new();
calc(reader, sha).unwrap()
};
assert_eq!(val, async_res);
assert_eq!(async_res, sync_res);
}
}
15 changes: 15 additions & 0 deletions src/openssl_sha256.rs
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,15 @@
use crate::CalculatorSelector;

pub type OpenSslSha256 = openssl::sha::Sha256;

impl CalculatorSelector for OpenSslSha256 {
type FinishType = [u8; 32];

fn update_inner(&mut self, data: &[u8]) {
self.update(data)
}

fn finish_inner(self) -> Self::FinishType {
self.finish()
}
}
Loading

0 comments on commit f0046c2

Please sign in to comment.