Remove old code based on map storage of stream (#5)

Author: dev870

server/src/main.rs

@@ -1,38 +1,32 @@
-use actix_web::{put, get, App, HttpRequest, HttpResponse, HttpServer};
-mod stream;
-mod s3;
+use actix_web::{web, App, HttpRequest, HttpResponse, HttpServer};
 
+mod s3;
 
+fn read_config() -> s3::ConfigToml {
+    s3::read_config("Config.toml")
+}
 
-#[put("/{stream}")]
 async fn put_stream(req: HttpRequest) -> HttpResponse {
     let stream_name: String = req.match_info().get("stream").unwrap().parse().unwrap();
     let stream_name_clone = stream_name.clone();
-    match stream::insert_stream(stream_name, stream::Stream::empty()) {
-        None => HttpResponse::Ok().body(format!("Created Stream {}", stream_name_clone)),
-        Some(_) =>   {
-            HttpResponse::Ok().body(format!("Updated Stream {}", stream_name_clone))
-        } 
-    }
-}
+    let s3_bucket = read_config().s3.aws_bucket_name;
+    let s3_client = s3::init_s3client(read_config());
 
-#[get("/list")]
-async fn list_stream() -> HttpResponse {
-    let map = stream::STREAMS.lock().unwrap();
-    for  (k, _) in map.iter() {
-        println!("key={}", k);
+    match s3::create_stream(Some(s3_client), s3_bucket, stream_name) {
+        Ok(_) => HttpResponse::Ok().body(format!("Created Stream {}", stream_name_clone)),
+        Err(_) => {
+            HttpResponse::Ok().body(format!("Failed to create Stream {}", stream_name_clone))
+        }
     }
-    HttpResponse::Ok().body("Listed Stream")
 }
 
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
-    let read_config = s3::read_config("Config.toml");
-    let init_s3client = s3::init_s3client(read_config);
-    let create_stream = s3::create_stream(init_s3client.0,init_s3client.1, "stream_name");
-    println!("{:?}", create_stream);
-    HttpServer::new(|| App::new().service(put_stream).service(list_stream))
+    HttpServer::new(|| {
+        App::new()
+            .route("/{stream}", web::put().to(put_stream))
+    })
     .bind("127.0.0.1:8080")?
     .run()
     .await
-}
+}

server/src/s3.rs

@@ -1,25 +1,21 @@
 use std::fs;
 use serde::Deserialize;
 use std::env;
-use std::path::Path;
 use http::{Uri};
-use aws_sdk_s3::{Client,ByteStream,Config,Endpoint,Error};
+use aws_sdk_s3::{Client,Config,Endpoint,Error};
 
-
-#[derive(Deserialize)]
-#[derive(Debug)]
+#[derive(Debug,Deserialize)]
 pub struct ConfigToml {
-    s3: S3,
+    pub s3: S3,
 }
 
-#[derive(Deserialize)]
-#[derive(Debug)]
-struct S3 {
+#[derive(Debug,Deserialize)]
+pub struct S3 {
     aws_access_key_id: String,
     aws_secret_key: String,
     aws_default_region: String,
     aws_endpoint_url: String,
-    aws_bucket_name: String,
+    pub aws_bucket_name: String,
 }
 
 pub fn read_config(file_name: &str) -> ConfigToml {
@@ -28,12 +24,10 @@ pub fn read_config(file_name: &str) -> ConfigToml {
     config_info
 }
 
-pub fn init_s3client(config_info: ConfigToml) -> (aws_sdk_s3::Client, String) {
-
+pub fn init_s3client(config_info: ConfigToml) -> aws_sdk_s3::Client {
     let ( secret_key, access_key, region, endpoint_url, bucket_name ) = ("AWS_SECRET_ACCESS_KEY", "AWS_ACCESS_KEY_ID", "AWS_DEFAULT_REGION", "AWS_ENDPOINT_URL", "AWS_BUCKET_NAME");
     let  data = vec![secret_key, access_key, region, endpoint_url];
 
-
     for data in data.iter() {
         match data {
             &"AWS_SECRET_ACCESS_KEY" => env::set_var(secret_key, &config_info.s3.aws_secret_key),
@@ -42,40 +36,30 @@ pub fn init_s3client(config_info: ConfigToml) -> (aws_sdk_s3::Client, String) {
             &"AWS_ENDPOINT_URL" => env::set_var(endpoint_url, &config_info.s3.aws_endpoint_url),
             &"AWS_BUCKET_NAME" => env::set_var(bucket_name, &config_info.s3.aws_bucket_name),
             _ => println!("{:?}",config_info),
+        }
     }
-    }
-    
-    println!("{}", &config_info.s3.aws_bucket_name);
-
     let ep = env::var("AWS_ENDPOINT_URL").unwrap_or("none".to_string());
     let uri = ep.parse::<Uri>().unwrap();
     let endpoint = Endpoint::immutable(uri);
     let config = Config::builder().endpoint_resolver(endpoint).build();
-
-    return (Client::from_conf(config), config_info.s3.aws_bucket_name)
+    Client::from_conf(config)
 }
 
 #[tokio::main]
-pub async fn create_stream(s3_client: aws_sdk_s3::Client,bucket_name: String, stream_name: &str) -> Result<(), Error> {
-
-    let body = ByteStream::from_path(Path::new("Cargo.toml")).await;
-    
-    match body {
-        Ok(b) => {
-            let resp = s3_client
-                .put_object()
-                .bucket(bucket_name)
-                .key(format!("{}{}", stream_name, "/.schema"))
-                .body(b)
-                .send()
-                .await?;
-
+pub async fn create_stream(s3_client: Option<aws_sdk_s3::Client>,bucket_name: String, stream_name: String) -> Result<(), Error> {
+    match s3_client {
+        Some(client) => {    
+            let resp = client
+            .put_object()
+            .bucket(bucket_name)
+            .key(format!("{}{}", stream_name, "/.schema"))
+            .send()
+            .await?;
             println!("Upload success. Version: {:?}", resp.version_id);
-        }
-        Err(e) => {
-            println!("Got an error DOING SOMETHING:");
-            println!("{}", e);
-        }
+            Ok(())     
+        },
+        _ => {
+            Ok(())
+        },
     }
-    Ok(())     
 }