S3-Mediaconvert

Cargo.toml

[package]
name = "rusoto"
version = "0.1.0"
authors = ["Kai <kai.park1201@gmail.com>"]
edition = "2018"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
rusoto_core = "0.44.0"
rusoto_s3 = "0.44.0"
rusoto_mediaconvert = "0.44.0"
rusoto_credential = "0.44.0"
aws_lambda_events = "^0.3.0"
# lambda_runtime = "^0.2.1"
tokio = { version = "0.2", features = ["macros"] }
lambda = { git = "https://github.com/awslabs/aws-lambda-rust-runtime/", branch = "master"}
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
serde_derive = "^1"
log = "^0.4"
simple_logger = "^1"
openssl = { version = "0.10", features = ["vendored"] }
dotenv = "0.15.0"
dotenv_codegen = "0.15.0"
chrono = {version = "0.4", features = ["serde"] }
# tokio = { version = "0.2", features = ["rt-core"] }
# ffmpeg-next = "4.2.1"

[[bin]]
name = "bootstrap"
path = "src/main.rs"

main.rs

#[macro_use]
extern crate dotenv_codegen;

use std::{collections::HashMap};

// use lambda_runtime::{error::HandlerError, lambda, Context};
use serde_derive::{Serialize};
use rusoto_core::{Region};

use rusoto_mediaconvert::{MediaConvert, MediaConvertClient, CreateJobRequest, Input, JobSettings};
use rusoto_mediaconvert::{VideoSelector};
use aws_lambda_events::event::s3::S3Event;
use rusoto_s3::{GetObjectRequest, S3Client, S3};
// use rusoto_credential::StaticProvider;

// use ffmpeg_next as ffmpeg;
use lambda::{handler_fn};
use serde_json::Value;
type Error = Box<dyn std::error::Error + Send + Sync + 'static>;

mod utils;

use utils::media_convert_utils::get_audio_selector;

#[tokio::main]
async fn main() -> Result<(), Error>  {
  // lambda!(my_handler);
  let func = handler_fn(my_handler);
  lambda::run(func).await;
  Ok(())
}

#[derive(Serialize)]
pub struct CustomOutput {
  status_code: i64,
  body: String
}

async fn my_handler(e: S3Event) -> Result<CustomOutput, Error> {
// async fn my_handler() -> Result<CustomOutput, HandlerError> {
  
    // $ cargo build --release --target x86_64-unknown-linux-musl
    // $ zip -j rust.zip ./target/x86_64-unknown-linux-musl/release/bootstrap


println!("catch event: {:?}", e);
    // let access_key = dotenv!("AWS_ACCESS_KEY_ID").to_owned();
    // let secret_key = dotenv!("AWS_SECRET_ACCESS_KEY").to_owned();
    // let credentials = StaticProvider::new_minimal(access_key, secret_key);
    // println!("credentials: {:?}", credentials);
    let s3_client = S3Client::new(Region::ApNortheast2);
    let upload_file = e.records[0].s3.object.key.as_ref().unwrap();
    let obj_req = GetObjectRequest{
      bucket: String::from("btoz-videos"),
      key: String::from(upload_file),
      ..Default::default()
    };

    let res = s3_client.get_object(obj_req).await;
    println!("{:?}", res);

    let bucket_name = dotenv!("UPLOAD_BUCKET_NAME").to_owned();

    let mediaconvert_endpoint = dotenv!("MEDIACONVERT_ENDPOINT").to_owned();
    let mut job_template = Some(dotenv!("PORTRAIT_JOB_TEMPLATE_ARN").to_owned());

    // // if is_portrait("https://videos.s3.ap-northeast-2.amazonaws.com/filename.mp4".to_string()) {
    // //
    // //   println!("33 Video is portrait");
    // //   job_template = Some(dotenv!("PORTRAIT_JOB_TEMPLATE_ARN").to_owned());
    // // }
    //
    let role = dotenv!("JOB_ROLE_ARN").to_owned();

    println!("mediaconvert_endpoint {:?} buket {:?} file uploaded", mediaconvert_endpoint, upload_file);
    println!("job_template {:?} buket {:?} file uploaded", job_template, upload_file);
    println!("role {:?} buket {:?} file uploaded", role, upload_file);
    println!("Recived {:?} buket {:?} file uploaded", bucket_name, upload_file);

    //
    let mediaconver_client = MediaConvertClient::new(Region::Custom{
      name: "ap-northeast-2".to_owned(),
      endpoint: mediaconvert_endpoint
    });
    let mut audio_selector_hashmap = HashMap::new();
    let audio_selector = get_audio_selector();
    // println!("s3 Link is {:?}",format!("s3://btoz-videos/{:}", upload_file));
    audio_selector_hashmap.insert("Audio Selector 1".to_owned(), audio_selector);
    let job_input =
    Input{
      file_input: Some(format!("s3://{:}/{:}",bucket_name, upload_file).to_owned()),
      audio_selectors: Some(audio_selector_hashmap),
      ..Default::default()
    };

    let job_setting = JobSettings {
      inputs: Some(vec![job_input]),
      ..Default::default()
    };

    let mut user_metadata: ::std::collections::HashMap<String, String> = HashMap::new();
    user_metadata.insert("name".to_string(), upload_file.to_string());

    let create_job = mediaconver_client.create_job(CreateJobRequest {
      job_template,
      role,
      settings: job_setting,
      user_metadata: Some(user_metadata),
      ..Default::default()
    });
    let job_result = create_job.await;
    println!("result: {:?}", job_result);

    Ok(CustomOutput {
        status_code: 200,
        body: format!("Upload job finished ")
        // body: format!("Upload job ({:?}) finished with job_id : {:?} ", c.aws_request_id, job_result)
    })
}


// pub fn is_portrait(video_url: String) -> bool {
//
//   ffmpeg::init().unwrap();
//
//   let mut rotate = 0;
//   let mut width = 720;
//   let mut height = 1280;
//
//     // match ffmpeg::format::input(&"https://btoz-video-output.s3.ap-northeast-2.amazonaws.com/20200604/coverr-thai-ice-cream-1567246825951.mp4") {
//     match ffmpeg::format::input(&video_url) {
//         Ok(context) => {
//             for stream in context.streams() {
//                 for (k, v) in stream.metadata().iter() {
//                     if k == "rotate" {
//                       rotate = v.parse::<u64>().unwrap();
//                     }
//                 }
//                 let codec = stream.codec();
//
//                 if let Ok(video) = codec.decoder().video() {
//                    width = video.width();
//                    height = video.height();
//                 }
//             }
//             println!("\n\n22width: {}, height: {}, rotate: {}", width, height, rotate);
//         }
//         Err(error) => println!("error: {}", error),
//     }
//
//     ((width < height) && ( rotate / 90 == 0 || rotate / 90 == 2 )) ||
//     ((width > height) && ( rotate / 90 == 1 || rotate / 90 == 3 ))
// }

utils-media_convert_utils.rs

use rusoto_mediaconvert::{VideoSelector, AudioSelector, Input};
use std::collections::HashMap;
pub fn get_audio_selector() -> AudioSelector {
  let audio_selector = AudioSelector{
    offset: Some(0),
    default_selection: Some("DEFAULT".to_owned()),
    program_selection: Some(1),
    ..Default::default()
  };
  audio_selector
}

pub fn get_job_input(bucket_name: &str, upload_file: &str, audio_selector_hashmap: HashMap<String, String> ) {
  Input{
    file_input: Some(format!("s3://{:}/{:}",bucket_name, upload_file).to_owned()),
    audio_selectors: Some(audio_selector_hashmap),
    ..Default::default()
  };
}

utils-mod.rs

pub mod media_convert_utils;