Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/bisohns/waihona
Rust crate for performing cloud storage CRUD actions across major cloud providers e.g aws
https://github.com/bisohns/waihona
aws azure blob-storage cloud-providers gcp rust-library s3 storage
Last synced: 28 days ago
JSON representation
Rust crate for performing cloud storage CRUD actions across major cloud providers e.g aws
- Host: GitHub
- URL: https://github.com/bisohns/waihona
- Owner: bisohns
- License: mit
- Created: 2021-02-06T11:58:02.000Z (almost 4 years ago)
- Default Branch: main
- Last Pushed: 2022-03-26T20:54:32.000Z (over 2 years ago)
- Last Synced: 2024-11-17T01:06:46.638Z (about 1 month ago)
- Topics: aws, azure, blob-storage, cloud-providers, gcp, rust-library, s3, storage
- Language: Rust
- Homepage: https://crates.io/crates/waihona
- Size: 136 KB
- Stars: 50
- Watchers: 2
- Forks: 9
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# waihona
[](https://crates.io/crates/waihona)
[](https://github.com/bisoncorps/waihona/actions)
[](https://github.com/bisoncorps/waihona/actions)
## Usage
All cloud providers are on by default, to specify a single provider e.g aws:
```toml
[dependencies]
waihona={version = "0.0.3", features = ["aws"], default-features = false }
```
Rust library for cloud storage across major cloud providers
It aims to provide simple to use functions to perform CRUD operations on
buckets and blobs.
Waihona simply means storage in Hawaiian
## Feature Flags
The following feature flags exist for this crate
- [x] `aws`: Enable aws provider and dependencies
- [x] `gcp`: Enable gcp provider and dependencies
- [x] `azure`: Enable azure provider and dependencies
## Traits
Three major traits control behaviour for each provider
Buckets -> Bucket -> Blob
```rust
// all methods of traits are async
use bytes::Bytes;
trait Buckets
where T: Bucket
, P: Blob{
fn open(&mut self, bucket_name: &str);
fn create(&mut self, bucket_name: &str, location: Option);
fn list(&mut self);
fn delete(&mut self, bucket_name: &str);
fn exists(&mut self, bucket_name: &str);
}
trait Bucket
where P: Blob{
fn list_blobs(&self, marker: Option);
fn get_blob(&self, blob_path: &str, content_range: Option);
fn copy_blob(&self, blob_path: &str, blob_destination_path: &str, content_type: Option);
fn write_blob(&self, blob_name: &str, content: Option);
fn delete_blob(&self, blob_path: &str);
}
trait Blob {
fn delete(&self);
fn copy(&self, blob_destination_path: &str, content_type: Option );
fn write(&self, content: Option);
fn read(&mut self);
}
```
### Examples
These quick examples will show you how to make use of the
library for basic actions
List buckets from project waihona on GCP
```rust
// ensure to export service credential using GOOGLE_APPLICATION_CREDENTIALS
#[cfg(feature = "gcp")]
use waihona::providers::gcp::GcpBucket;
#[tokio::test]
#[cfg(feature = "gcp")]
async fn test_list_buckets() -> Vec {
// Import Buckets trait from crate
use waihona::types::bucket::{Buckets};
use waihona::providers::gcp;
let mut gcp_buckets = providers::gcp::GcpBuckets::new(
"waihona"
);
// Returns (Vec)
// where Option is the cursor for the token for next page listing
let resp = gcp_buckets.list().await;
resp[0]
}
```
Check bucket waihona exists on AWS
```rust
#[tokio::test]
#[cfg(feature = "aws")]
async fn test_bucket_exists() -> bool {
use waihona::types::bucket::{Buckets};
use waihona::providers;
let mut aws_buckets = providers::aws::AwsBuckets::new(
"us-east-2"
);
let resp = aws_buckets.exists(
"waihona"
).await;
// OR you can do
let resp = providers::aws::AwsBucket::exists(
"us-east-2",
"waihona"
).await;
resp
}
```
Write content to a blob "example.txt" in waihona bucket on Azure
```rust
#[cfg(feature = "azure")]
use waihona::providers::azure::AzureBlob;
#[tokio::test]
#[cfg(feature = "azure")]
async fn test_create_blob() -> AzureBlob {
use waihona::types::bucket::{Buckets, Bucket};
use waihona::types::blob::{Blob};
use waihona::providers;
use bytes::Bytes;
let mut azure_buckets = providers::azure::AzureBuckets::new("waihona".to_owned());
let waihona = azure_buckets.open(
"waihona",
).await.unwrap();
let mut blob = waihona.write_blob(
"example.txt",
Some(Bytes::from("Hello world"))
).await
.unwrap();
let read = blob.read().await.unwrap();
assert!(read.eq(&Bytes::from("Hello world")));
}
```
Copy file content from "example.txt" blob on AWS to blob on GCP
and delete AWS blob afterwards
assuming waihona buckets exist on both platforms
```rust
#[cfg(feature = "gcp")]
use waihona::providers::gcp::GcpBlob;
#[tokio::test]
#[cfg(all(feature = "gcp", feature = "aws" ))]
async fn test_transfer_blob() -> GcpBlob {
use waihona::types::bucket::{Buckets, Bucket};
use waihona::types::blob::{Blob};
use waihona::providers;
use bytes::Bytes;
let mut aws_blob = providers::aws::AwsBlob::get(
"us-east-2", // Region
"waihona", // Bucket name
"example.txt", // Blob name
None // Content range
).await
.unwrap();
let mut gcp_blob = providers::gcp::GcpBlob::get(
"gcp-project-name", // Project name
"waihona", // Bucket name
"example.txt", // Blob name
None // Content range
).await
.unwrap();
let content: Bytes = aws_blob.read().unwrap();
gcp_blob.write(Some(content)).await.unwrap();
aws_blob.delete().unwrap();
gcp_blob
}
```
## License
This project is opened under the [MIT License](./LICENSE) which allows very broad use for both academic and commercial purposes